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

cribl_control_plane/models/functiondistinct.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, List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+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
+    id: FunctionDistinctID
+    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[DistinctConfigurationTypedDict]
+
+
+class FunctionDistinct(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionDistinctID
+
+    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[DistinctConfiguration], pydantic.Field(alias="schema")
+    ] = None

cribl_control_plane/models/functiondnslookup.py

@@ -0,0 +1,250 @@
+"""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 ConfigDict, field_serializer
+from pydantic.functional_validators import PlainValidator
+from typing import Any, Dict, List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionDNSLookupID(str, Enum):
+    DNS_LOOKUP = "dns_lookup"
+
+
+class ResourceRecordType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""The DNS record type (RR) to return. Defaults to 'A'."""
+
+    # A
+    A = "A"
+    # AAAA
+    AAAA = "AAAA"
+    # ANY
+    ANY = "ANY"
+    # CNAME
+    CNAME = "CNAME"
+    # MX
+    MX = "MX"
+    # NAPTR
+    NAPTR = "NAPTR"
+    # NS
+    NS = "NS"
+    # PTR
+    PTR = "PTR"
+    # SOA
+    SOA = "SOA"
+    # SRV
+    SRV = "SRV"
+    # TXT
+    TXT = "TXT"
+
+
+class DNSLookupFieldTypedDict(TypedDict):
+    in_field_name: NotRequired[str]
+    resource_record_type: NotRequired[ResourceRecordType]
+    r"""The DNS record type (RR) to return. Defaults to 'A'."""
+    out_field_name: NotRequired[str]
+    r"""Name of field to add lookup results to. Leave blank to overwrite the lookup field."""
+
+
+class DNSLookupField(BaseModel):
+    in_field_name: Annotated[Optional[str], pydantic.Field(alias="inFieldName")] = None
+
+    resource_record_type: Annotated[
+        Annotated[
+            Optional[ResourceRecordType], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="resourceRecordType"),
+    ] = ResourceRecordType.A
+    r"""The DNS record type (RR) to return. Defaults to 'A'."""
+
+    out_field_name: Annotated[Optional[str], pydantic.Field(alias="outFieldName")] = (
+        None
+    )
+    r"""Name of field to add lookup results to. Leave blank to overwrite the lookup field."""
+
+    @field_serializer("resource_record_type")
+    def serialize_resource_record_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.ResourceRecordType(value)
+            except ValueError:
+                return value
+        return value
+
+
+class ReverseLookupFieldTypedDict(TypedDict):
+    in_field_name: NotRequired[str]
+    r"""Name of the field containing the IP to look up. If the field value is not in IPv4 or IPv6 format, the lookup is skipped."""
+    out_field_name: NotRequired[str]
+    r"""Name of field to add the resolved domain to. Leave blank to overwrite the lookup field."""
+
+
+class ReverseLookupField(BaseModel):
+    in_field_name: Annotated[Optional[str], pydantic.Field(alias="inFieldName")] = None
+    r"""Name of the field containing the IP to look up. If the field value is not in IPv4 or IPv6 format, the lookup is skipped."""
+
+    out_field_name: Annotated[Optional[str], pydantic.Field(alias="outFieldName")] = (
+        None
+    )
+    r"""Name of field to add the resolved domain to. Leave blank to overwrite the lookup field."""
+
+
+class LogLevelForFailedLookups(str, Enum, metaclass=utils.OpenEnumMeta):
+    # silly
+    SILLY = "silly"
+    # debug
+    DEBUG = "debug"
+    # info
+    INFO = "info"
+    # warn
+    WARN = "warn"
+    # error
+    ERROR = "error"
+
+
+class FunctionDNSLookupSchemaTypedDict(TypedDict):
+    dns_lookup_fields: NotRequired[List[DNSLookupFieldTypedDict]]
+    r"""List of field names on which to perform DNS lookup"""
+    reverse_lookup_fields: NotRequired[List[ReverseLookupFieldTypedDict]]
+    r"""List of field names on which to perform reverse DNS lookup"""
+    dns_servers: NotRequired[List[str]]
+    r"""IPs, in RFC 5952 format, of the DNS servers to use for resolution. Examples: IPv4 1.1.1.1, 4.2.2.2:53, or IPv6 [2001:4860:4860::8888], [2001:4860:4860::8888]:1053. If not specified, system's DNS will be used."""
+    cache_ttl: NotRequired[float]
+    r"""How frequently to expire and refetch DNS cache. Use 0 to disable."""
+    max_cache_size: NotRequired[float]
+    r"""The maximum number of DNS resolutions to be cached locally. Leave at default unless you understand the implications of changing."""
+    use_resolv_conf: NotRequired[bool]
+    r"""Attempt to resolve DNS short names using the search or domain directive from /etc/resolv.conf"""
+    lookup_fallback: NotRequired[bool]
+    r"""If unable to resolve a DNS short name, make a DNS.lookup() call to resolve it. Caution: This might degrade performance in unrelated areas of @{product}."""
+    domain_overrides: NotRequired[List[str]]
+    r"""Specify fallback values for the DNS resolver to use when it cannot resolve a DNS short name"""
+    lookup_fail_log_level: NotRequired[LogLevelForFailedLookups]
+
+
+class FunctionDNSLookupSchema(BaseModel):
+    model_config = ConfigDict(
+        populate_by_name=True, arbitrary_types_allowed=True, extra="allow"
+    )
+    __pydantic_extra__: Dict[str, Any] = pydantic.Field(init=False)
+
+    dns_lookup_fields: Annotated[
+        Optional[List[DNSLookupField]], pydantic.Field(alias="dnsLookupFields")
+    ] = None
+    r"""List of field names on which to perform DNS lookup"""
+
+    reverse_lookup_fields: Annotated[
+        Optional[List[ReverseLookupField]], pydantic.Field(alias="reverseLookupFields")
+    ] = None
+    r"""List of field names on which to perform reverse DNS lookup"""
+
+    dns_servers: Annotated[Optional[List[str]], pydantic.Field(alias="dnsServers")] = (
+        None
+    )
+    r"""IPs, in RFC 5952 format, of the DNS servers to use for resolution. Examples: IPv4 1.1.1.1, 4.2.2.2:53, or IPv6 [2001:4860:4860::8888], [2001:4860:4860::8888]:1053. If not specified, system's DNS will be used."""
+
+    cache_ttl: Annotated[Optional[float], pydantic.Field(alias="cacheTTL")] = 30
+    r"""How frequently to expire and refetch DNS cache. Use 0 to disable."""
+
+    max_cache_size: Annotated[Optional[float], pydantic.Field(alias="maxCacheSize")] = (
+        5000
+    )
+    r"""The maximum number of DNS resolutions to be cached locally. Leave at default unless you understand the implications of changing."""
+
+    use_resolv_conf: Annotated[
+        Optional[bool], pydantic.Field(alias="useResolvConf")
+    ] = False
+    r"""Attempt to resolve DNS short names using the search or domain directive from /etc/resolv.conf"""
+
+    lookup_fallback: Annotated[
+        Optional[bool], pydantic.Field(alias="lookupFallback")
+    ] = False
+    r"""If unable to resolve a DNS short name, make a DNS.lookup() call to resolve it. Caution: This might degrade performance in unrelated areas of @{product}."""
+
+    domain_overrides: Annotated[
+        Optional[List[str]], pydantic.Field(alias="domainOverrides")
+    ] = None
+    r"""Specify fallback values for the DNS resolver to use when it cannot resolve a DNS short name"""
+
+    lookup_fail_log_level: Annotated[
+        Annotated[
+            Optional[LogLevelForFailedLookups],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="lookupFailLogLevel"),
+    ] = LogLevelForFailedLookups.ERROR
+
+    @property
+    def additional_properties(self):
+        return self.__pydantic_extra__
+
+    @additional_properties.setter
+    def additional_properties(self, value):
+        self.__pydantic_extra__ = value  # pyright: ignore[reportIncompatibleVariableOverride]
+
+    @field_serializer("lookup_fail_log_level")
+    def serialize_lookup_fail_log_level(self, value):
+        if isinstance(value, str):
+            try:
+                return models.LogLevelForFailedLookups(value)
+            except ValueError:
+                return value
+        return value
+
+
+class FunctionDNSLookupTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionDNSLookupID
+    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[FunctionDNSLookupSchemaTypedDict]
+
+
+class FunctionDNSLookup(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionDNSLookupID
+
+    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[FunctionDNSLookupSchema], pydantic.Field(alias="schema")
+    ] = None

cribl_control_plane/models/functiondrop.py

@@ -0,0 +1,73 @@
+"""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 FunctionDropID(str, Enum):
+    DROP = "drop"
+
+
+class FunctionDropSchemaTypedDict(TypedDict):
+    pass
+
+
+class FunctionDropSchema(BaseModel):
+    pass
+
+
+class FunctionDropTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionDropID
+    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[FunctionDropSchemaTypedDict]
+
+
+class FunctionDrop(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionDropID
+
+    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[FunctionDropSchema], pydantic.Field(alias="schema")] = (
+        None
+    )

cribl_control_plane/models/functiondropdimensions.py

@@ -0,0 +1,87 @@
+"""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 FunctionDropDimensionsID(str, Enum):
+    DROP_DIMENSIONS = "drop_dimensions"
+
+
+class FunctionDropDimensionsSchemaTypedDict(TypedDict):
+    drop_dimensions: List[str]
+    r"""One or more dimensions to be dropped. Supports wildcard expressions. Warning: Using wildcard '*' causes all dimensions in the event to be dropped."""
+    time_window: NotRequired[str]
+    r"""The time span of the tumbling window for aggregating events. Must be a valid time string (such as 10s)."""
+    flush_on_input_close: NotRequired[bool]
+    r"""Flush aggregations when an input stream is closed. If disabled, aggregations are flushed based on Time Window Settings instead."""
+
+
+class FunctionDropDimensionsSchema(BaseModel):
+    drop_dimensions: Annotated[List[str], pydantic.Field(alias="dropDimensions")]
+    r"""One or more dimensions to be dropped. Supports wildcard expressions. Warning: Using wildcard '*' causes all dimensions in the event to be dropped."""
+
+    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)."""
+
+    flush_on_input_close: Annotated[
+        Optional[bool], pydantic.Field(alias="flushOnInputClose")
+    ] = True
+    r"""Flush aggregations when an input stream is closed. If disabled, aggregations are flushed based on Time Window Settings instead."""
+
+
+class FunctionDropDimensionsTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionDropDimensionsID
+    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[FunctionDropDimensionsSchemaTypedDict]
+
+
+class FunctionDropDimensions(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionDropDimensionsID
+
+    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[FunctionDropDimensionsSchema], pydantic.Field(alias="schema")
+    ] = None

cribl_control_plane/models/functiondynamicsampling.py

@@ -0,0 +1,121 @@
+"""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 FunctionDynamicSamplingID(str, Enum):
+    DYNAMIC_SAMPLING = "dynamic_sampling"
+
+
+class SampleMode(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Defines how sample rate will be derived: log(previousPeriodCount) or sqrt(previousPeriodCount)"""
+
+    # Logarithmic
+    LOG = "log"
+    # Square Root
+    SQRT = "sqrt"
+
+
+class FunctionDynamicSamplingSchemaTypedDict(TypedDict):
+    mode: NotRequired[SampleMode]
+    r"""Defines how sample rate will be derived: log(previousPeriodCount) or sqrt(previousPeriodCount)"""
+    key_expr: NotRequired[str]
+    r"""Expression used to derive sample group key. Example:`${domain}:${status}`. Each sample group will have its own derived sampling rate based on volume. Defaults to `${host}`."""
+    sample_period: NotRequired[float]
+    r"""How often (in seconds) sample rates will be adjusted"""
+    min_events: NotRequired[float]
+    r"""Minimum number of events that must be received in previous sample period for sampling mode to be applied to current period. If the number of events received for a sample group is less than this minimum, a sample rate of 1:1 is used."""
+    max_sample_rate: NotRequired[float]
+    r"""Maximum sampling rate. If computed sampling rate is above this value, it will be limited to this value."""
+
+
+class FunctionDynamicSamplingSchema(BaseModel):
+    mode: Annotated[Optional[SampleMode], PlainValidator(validate_open_enum(False))] = (
+        SampleMode.LOG
+    )
+    r"""Defines how sample rate will be derived: log(previousPeriodCount) or sqrt(previousPeriodCount)"""
+
+    key_expr: Annotated[Optional[str], pydantic.Field(alias="keyExpr")] = "`${host}`"
+    r"""Expression used to derive sample group key. Example:`${domain}:${status}`. Each sample group will have its own derived sampling rate based on volume. Defaults to `${host}`."""
+
+    sample_period: Annotated[Optional[float], pydantic.Field(alias="samplePeriod")] = 30
+    r"""How often (in seconds) sample rates will be adjusted"""
+
+    min_events: Annotated[Optional[float], pydantic.Field(alias="minEvents")] = 30
+    r"""Minimum number of events that must be received in previous sample period for sampling mode to be applied to current period. If the number of events received for a sample group is less than this minimum, a sample rate of 1:1 is used."""
+
+    max_sample_rate: Annotated[
+        Optional[float], pydantic.Field(alias="maxSampleRate")
+    ] = 100
+    r"""Maximum sampling rate. If computed sampling rate is above this value, it will be limited to this value."""
+
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.SampleMode(value)
+            except ValueError:
+                return value
+        return value
+
+
+class FunctionDynamicSamplingTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionDynamicSamplingID
+    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[FunctionDynamicSamplingSchemaTypedDict]
+
+
+class FunctionDynamicSampling(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionDynamicSamplingID
+
+    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[FunctionDynamicSamplingSchema], pydantic.Field(alias="schema")
+    ] = None