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

cribl_control_plane/models/functionsensitivedatascanner.py

@@ -0,0 +1,128 @@
+"""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 FunctionSensitiveDataScannerID(str, Enum):
+    SENSITIVE_DATA_SCANNER = "sensitive_data_scanner"
+
+
+class FunctionSensitiveDataScannerRuleTypedDict(TypedDict):
+    ruleset_id: str
+    r"""The ID of the ruleset to use for the scan"""
+    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]
+
+
+class FunctionSensitiveDataScannerRule(BaseModel):
+    ruleset_id: Annotated[str, pydantic.Field(alias="rulesetId")]
+    r"""The ID of the ruleset to use for the scan"""
+
+    replace_expr: Annotated[Optional[str], pydantic.Field(alias="replaceExpr")] = (
+        "'REDACTED'"
+    )
+    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
+
+
+class FunctionSensitiveDataScannerFlagTypedDict(TypedDict):
+    value: str
+    name: NotRequired[str]
+
+
+class FunctionSensitiveDataScannerFlag(BaseModel):
+    value: str
+
+    name: Optional[str] = None
+
+
+class FunctionSensitiveDataScannerSchemaTypedDict(TypedDict):
+    rules: List[FunctionSensitiveDataScannerRuleTypedDict]
+    fields: NotRequired[List[str]]
+    r"""Rulesets act on the events contained in these fields. Mitigation expressions apply to the scan results. Supports wildcards (*)."""
+    exclude_fields: NotRequired[List[str]]
+    r"""Fields that the mitigation expression will not be applied to. Supports wildcards (*)."""
+    flags: NotRequired[List[FunctionSensitiveDataScannerFlagTypedDict]]
+    r"""Fields to add when mitigation is applied to an event"""
+    include_detected_rules: NotRequired[bool]
+    r"""If enabled, Add matching ruleset IDs to a field called \"__detected\" """
+
+
+class FunctionSensitiveDataScannerSchema(BaseModel):
+    rules: List[FunctionSensitiveDataScannerRule]
+
+    fields: Optional[List[str]] = None
+    r"""Rulesets act on the events contained in these fields. Mitigation expressions apply to the scan results. Supports wildcards (*)."""
+
+    exclude_fields: Annotated[
+        Optional[List[str]], pydantic.Field(alias="excludeFields")
+    ] = None
+    r"""Fields that the mitigation expression will not be applied to. Supports wildcards (*)."""
+
+    flags: Optional[List[FunctionSensitiveDataScannerFlag]] = None
+    r"""Fields to add when mitigation is applied to an event"""
+
+    include_detected_rules: Annotated[
+        Optional[bool], pydantic.Field(alias="includeDetectedRules")
+    ] = True
+    r"""If enabled, Add matching ruleset IDs to a field called \"__detected\" """
+
+
+class FunctionSensitiveDataScannerTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionSensitiveDataScannerID
+    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[FunctionSensitiveDataScannerSchemaTypedDict]
+
+
+class FunctionSensitiveDataScanner(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionSensitiveDataScannerID
+
+    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[FunctionSensitiveDataScannerSchema], pydantic.Field(alias="schema")
+    ] = None

cribl_control_plane/models/functionserde.py

@@ -0,0 +1,161 @@
+"""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 FunctionSerdeID(str, Enum):
+    SERDE = "serde"
+
+
+class OperationMode(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Extract creates new fields. Reserialize extracts and filters fields, and then reserializes."""
+
+    # Extract
+    EXTRACT = "extract"
+    # Reserialize
+    RESERIALIZE = "reserialize"
+
+
+class FunctionSerdeType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Parser or formatter type to use"""
+
+    # 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"
+    # Regular Expression
+    REGEX = "regex"
+    # Grok
+    GROK = "grok"
+
+
+class FunctionSerdeSchemaTypedDict(TypedDict):
+    mode: NotRequired[OperationMode]
+    r"""Extract creates new fields. Reserialize extracts and filters fields, and then reserializes."""
+    type: NotRequired[FunctionSerdeType]
+    r"""Parser or formatter type to use"""
+    delim_char: NotRequired[Any]
+    quote_char: NotRequired[Any]
+    escape_char: NotRequired[Any]
+    null_value: NotRequired[Any]
+    src_field: NotRequired[str]
+    r"""Field containing text to be parsed"""
+    dst_field: NotRequired[str]
+    r"""Name of the field to add fields to. Extract mode only."""
+    clean_fields: NotRequired[Any]
+
+
+class FunctionSerdeSchema(BaseModel):
+    mode: Annotated[
+        Optional[OperationMode], PlainValidator(validate_open_enum(False))
+    ] = OperationMode.EXTRACT
+    r"""Extract creates new fields. Reserialize extracts and filters fields, and then reserializes."""
+
+    type: Annotated[
+        Optional[FunctionSerdeType], PlainValidator(validate_open_enum(False))
+    ] = FunctionSerdeType.CSV
+    r"""Parser or formatter type to use"""
+
+    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
+
+    src_field: Annotated[Optional[str], pydantic.Field(alias="srcField")] = "_raw"
+    r"""Field containing text to be parsed"""
+
+    dst_field: Annotated[Optional[str], pydantic.Field(alias="dstField")] = None
+    r"""Name of the field to add fields to. Extract mode only."""
+
+    clean_fields: Annotated[Optional[Any], pydantic.Field(alias="cleanFields")] = None
+
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OperationMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("type")
+    def serialize_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.FunctionSerdeType(value)
+            except ValueError:
+                return value
+        return value
+
+
+class FunctionSerdeTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionSerdeID
+    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[FunctionSerdeSchemaTypedDict]
+
+
+class FunctionSerde(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionSerdeID
+
+    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[FunctionSerdeSchema], pydantic.Field(alias="schema")
+    ] = None

cribl_control_plane/models/functionserialize.py

@@ -0,0 +1,134 @@
+"""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 FunctionSerializeID(str, Enum):
+    SERIALIZE = "serialize"
+
+
+class FunctionSerializeType(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 FunctionSerializeSchemaTypedDict(TypedDict):
+    type: NotRequired[FunctionSerializeType]
+    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 FunctionSerializeSchema(BaseModel):
+    type: Annotated[
+        Optional[FunctionSerializeType], PlainValidator(validate_open_enum(False))
+    ] = FunctionSerializeType.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.FunctionSerializeType(value)
+            except ValueError:
+                return value
+        return value
+
+
+class FunctionSerializeTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionSerializeID
+    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[FunctionSerializeSchemaTypedDict]
+
+
+class FunctionSerialize(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionSerializeID
+
+    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[FunctionSerializeSchema], pydantic.Field(alias="schema")
+    ] = None

cribl_control_plane/models/functionsidlookup.py

@@ -0,0 +1,93 @@
+"""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 FunctionSidlookupID(str, Enum):
+    SIDLOOKUP = "sidlookup"
+
+
+class FunctionSidlookupFieldTypedDict(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 FunctionSidlookupField(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 FunctionSidlookupSchemaTypedDict(TypedDict):
+    fields: NotRequired[List[FunctionSidlookupFieldTypedDict]]
+    r"""Set of expressions matched to lookup responses"""
+
+
+class FunctionSidlookupSchema(BaseModel):
+    fields: Optional[List[FunctionSidlookupField]] = None
+    r"""Set of expressions matched to lookup responses"""
+
+
+class FunctionSidlookupTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionSidlookupID
+    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[FunctionSidlookupSchemaTypedDict]
+
+
+class FunctionSidlookup(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionSidlookupID
+
+    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[FunctionSidlookupSchema], pydantic.Field(alias="schema")
+    ] = None

cribl_control_plane/models/functionsnmptrapserialize.py

@@ -0,0 +1,144 @@
+"""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 FunctionSnmpTrapSerializeID(str, Enum):
+    SNMP_TRAP_SERIALIZE = "snmp_trap_serialize"
+
+
+class FunctionSnmpTrapSerializeAuthenticationProtocol(
+    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 FunctionSnmpTrapSerializeV3UserTypedDict(TypedDict):
+    name: NotRequired[str]
+    auth_protocol: NotRequired[FunctionSnmpTrapSerializeAuthenticationProtocol]
+    auth_key: NotRequired[Any]
+    priv_protocol: NotRequired[str]
+
+
+class FunctionSnmpTrapSerializeV3User(BaseModel):
+    name: Optional[str] = None
+
+    auth_protocol: Annotated[
+        Annotated[
+            Optional[FunctionSnmpTrapSerializeAuthenticationProtocol],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authProtocol"),
+    ] = FunctionSnmpTrapSerializeAuthenticationProtocol.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.FunctionSnmpTrapSerializeAuthenticationProtocol(value)
+            except ValueError:
+                return value
+        return value
+
+
+class FunctionSnmpTrapSerializeSchemaTypedDict(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[FunctionSnmpTrapSerializeV3UserTypedDict]
+
+
+class FunctionSnmpTrapSerializeSchema(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[FunctionSnmpTrapSerializeV3User], pydantic.Field(alias="v3User")
+    ] = None
+
+
+class FunctionSnmpTrapSerializeTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionSnmpTrapSerializeID
+    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[FunctionSnmpTrapSerializeSchemaTypedDict]
+
+
+class FunctionSnmpTrapSerialize(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionSnmpTrapSerializeID
+
+    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[FunctionSnmpTrapSerializeSchema], pydantic.Field(alias="schema")
+    ] = None