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

cribl_control_plane/models/collectorgooglecloudstorage.py

@@ -0,0 +1,131 @@
+"""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 List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class CollectorGoogleCloudStorageType(str, Enum):
+    r"""Collector type: google_cloud_storage"""
+
+    GOOGLE_CLOUD_STORAGE = "google_cloud_storage"
+
+
+class CollectorGoogleCloudStorageExtractorTypedDict(TypedDict):
+    key: str
+    r"""A token from the template path, such as epoch"""
+    expression: str
+    r"""JavaScript expression that receives token under \"value\" variable, and evaluates to populate event fields, such as {date: new Date(+value*1000)}"""
+
+
+class CollectorGoogleCloudStorageExtractor(BaseModel):
+    key: str
+    r"""A token from the template path, such as epoch"""
+
+    expression: str
+    r"""JavaScript expression that receives token under \"value\" variable, and evaluates to populate event fields, such as {date: new Date(+value*1000)}"""
+
+
+class CollectorGoogleCloudStorageAuthenticationMethod(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    r"""Enter account credentials manually, select a secret that references your credentials, or use Google Application Default Credentials"""
+
+    AUTO = "auto"
+    MANUAL = "manual"
+    SECRET = "secret"
+
+
+class CollectorGoogleCloudStorageTypedDict(TypedDict):
+    type: CollectorGoogleCloudStorageType
+    r"""Collector type: google_cloud_storage"""
+    bucket: str
+    r"""Name of the bucket to collect from. This value can be a constant or a JavaScript expression that can only be evaluated at init time. Example referencing a Global Variable: `myBucket-${C.vars.myVar}`."""
+    output_name: NotRequired[str]
+    r"""Name of the predefined Destination that will be used to auto-populate Collector settings"""
+    path: NotRequired[str]
+    r"""The directory from which to collect data. Templating is supported, such as myDir/${datacenter}/${host}/${app}/. Time-based tokens are also supported, such as myOtherDir/${_time:%Y}/${_time:%m}/${_time:%d}/."""
+    extractors: NotRequired[List[CollectorGoogleCloudStorageExtractorTypedDict]]
+    r"""Allows using template tokens as context for expressions that enrich discovery results. For example, given a template /path/${epoch}, an extractor under key \"epoch\" with an expression {date: new Date(+value*1000)}, will enrich discovery results with a human readable \"date\" field."""
+    endpoint: NotRequired[str]
+    r"""Google Cloud Storage service endpoint. If empty, the endpoint will default to https://storage.googleapis.com."""
+    disable_time_filter: NotRequired[bool]
+    r"""Used to disable Collector event time filtering when a date range is specified"""
+    recurse: NotRequired[bool]
+    r"""Recurse through subdirectories"""
+    max_batch_size: NotRequired[float]
+    r"""Maximum number of metadata objects to batch before recording as results"""
+    auth_type: NotRequired[CollectorGoogleCloudStorageAuthenticationMethod]
+    r"""Enter account credentials manually, select a secret that references your credentials, or use Google Application Default Credentials"""
+    parquet_chunk_size_mb: NotRequired[float]
+    r"""Maximum file size for each Parquet chunk"""
+    parquet_chunk_download_timeout: NotRequired[float]
+    r"""The maximum time allowed for downloading a Parquet chunk. Processing will abort if a chunk cannot be downloaded within the time specified."""
+
+
+class CollectorGoogleCloudStorage(BaseModel):
+    type: CollectorGoogleCloudStorageType
+    r"""Collector type: google_cloud_storage"""
+
+    bucket: str
+    r"""Name of the bucket to collect from. This value can be a constant or a JavaScript expression that can only be evaluated at init time. Example referencing a Global Variable: `myBucket-${C.vars.myVar}`."""
+
+    output_name: Annotated[Optional[str], pydantic.Field(alias="outputName")] = None
+    r"""Name of the predefined Destination that will be used to auto-populate Collector settings"""
+
+    path: Optional[str] = None
+    r"""The directory from which to collect data. Templating is supported, such as myDir/${datacenter}/${host}/${app}/. Time-based tokens are also supported, such as myOtherDir/${_time:%Y}/${_time:%m}/${_time:%d}/."""
+
+    extractors: Optional[List[CollectorGoogleCloudStorageExtractor]] = None
+    r"""Allows using template tokens as context for expressions that enrich discovery results. For example, given a template /path/${epoch}, an extractor under key \"epoch\" with an expression {date: new Date(+value*1000)}, will enrich discovery results with a human readable \"date\" field."""
+
+    endpoint: Optional[str] = None
+    r"""Google Cloud Storage service endpoint. If empty, the endpoint will default to https://storage.googleapis.com."""
+
+    disable_time_filter: Annotated[
+        Optional[bool], pydantic.Field(alias="disableTimeFilter")
+    ] = False
+    r"""Used to disable Collector event time filtering when a date range is specified"""
+
+    recurse: Optional[bool] = True
+    r"""Recurse through subdirectories"""
+
+    max_batch_size: Annotated[Optional[float], pydantic.Field(alias="maxBatchSize")] = (
+        10
+    )
+    r"""Maximum number of metadata objects to batch before recording as results"""
+
+    auth_type: Annotated[
+        Annotated[
+            Optional[CollectorGoogleCloudStorageAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
+    ] = CollectorGoogleCloudStorageAuthenticationMethod.MANUAL
+    r"""Enter account credentials manually, select a secret that references your credentials, or use Google Application Default Credentials"""
+
+    parquet_chunk_size_mb: Annotated[
+        Optional[float], pydantic.Field(alias="parquetChunkSizeMB")
+    ] = 5
+    r"""Maximum file size for each Parquet chunk"""
+
+    parquet_chunk_download_timeout: Annotated[
+        Optional[float], pydantic.Field(alias="parquetChunkDownloadTimeout")
+    ] = 600
+    r"""The maximum time allowed for downloading a Parquet chunk. Processing will abort if a chunk cannot be downloaded within the time specified."""
+
+    @field_serializer("auth_type")
+    def serialize_auth_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.CollectorGoogleCloudStorageAuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/collectorhealthcheck.py

@@ -0,0 +1,269 @@
+"""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 CollectorHealthCheckDiscoverType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task."""
+
+    # HTTP Request
+    HTTP = "http"
+    # JSON Response
+    JSON = "json"
+    # Item List
+    LIST = "list"
+    # None
+    NONE = "none"
+
+
+class CollectorHealthCheckDiscoveryTypedDict(TypedDict):
+    discover_type: NotRequired[CollectorHealthCheckDiscoverType]
+    r"""Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task."""
+
+
+class CollectorHealthCheckDiscovery(BaseModel):
+    discover_type: Annotated[
+        Annotated[
+            Optional[CollectorHealthCheckDiscoverType],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="discoverType"),
+    ] = CollectorHealthCheckDiscoverType.NONE
+    r"""Defines how task discovery will be performed. Use None to skip the discovery. Use HTTP Request to make a REST call to discover tasks. Use Item List to enumerate items for collect to retrieve. Use JSON Response to manually define discover tasks as a JSON array of objects. Each entry returned by the discover operation will result in a collect task."""
+
+    @field_serializer("discover_type")
+    def serialize_discover_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.CollectorHealthCheckDiscoverType(value)
+            except ValueError:
+                return value
+        return value
+
+
+class HealthCheckMethod(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Health check HTTP method."""
+
+    # GET
+    GET = "get"
+    # POST
+    POST = "post"
+    # POST with Body
+    POST_WITH_BODY = "post_with_body"
+
+
+class CollectorHealthCheckCollectRequestHeaderTypedDict(TypedDict):
+    name: str
+    r"""Header Name"""
+    value: str
+    r"""JavaScript expression to compute the header value (can be a constant)."""
+
+
+class CollectorHealthCheckCollectRequestHeader(BaseModel):
+    name: str
+    r"""Header Name"""
+
+    value: str
+    r"""JavaScript expression to compute the header value (can be a constant)."""
+
+
+class CollectorHealthCheckAuthentication(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers."""
+
+    NONE = "none"
+    BASIC = "basic"
+    BASIC_SECRET = "basicSecret"
+    LOGIN = "login"
+    LOGIN_SECRET = "loginSecret"
+    OAUTH = "oauth"
+    OAUTH_SECRET = "oauthSecret"
+
+
+class CollectorHealthCheckHiddenDefaultBreakers(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    CRIBL = "Cribl"
+
+
+class CollectorHealthCheckRetryType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""The algorithm to use when performing HTTP retries"""
+
+    # Disabled
+    NONE = "none"
+    # Backoff
+    BACKOFF = "backoff"
+    # Static
+    STATIC = "static"
+
+
+class CollectorHealthCheckRetryRulesTypedDict(TypedDict):
+    type: NotRequired[CollectorHealthCheckRetryType]
+    r"""The algorithm to use when performing HTTP retries"""
+    interval: NotRequired[Any]
+    limit: NotRequired[Any]
+    multiplier: NotRequired[Any]
+    codes: NotRequired[Any]
+    enable_header: NotRequired[Any]
+
+
+class CollectorHealthCheckRetryRules(BaseModel):
+    type: Annotated[
+        Optional[CollectorHealthCheckRetryType],
+        PlainValidator(validate_open_enum(False)),
+    ] = CollectorHealthCheckRetryType.BACKOFF
+    r"""The algorithm to use when performing HTTP retries"""
+
+    interval: Optional[Any] = None
+
+    limit: Optional[Any] = None
+
+    multiplier: Optional[Any] = None
+
+    codes: Optional[Any] = None
+
+    enable_header: Annotated[Optional[Any], pydantic.Field(alias="enableHeader")] = None
+
+    @field_serializer("type")
+    def serialize_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.CollectorHealthCheckRetryType(value)
+            except ValueError:
+                return value
+        return value
+
+
+class CollectorHealthCheckType(str, Enum):
+    r"""Collector type: health_check"""
+
+    HEALTH_CHECK = "health_check"
+
+
+class CollectorHealthCheckTypedDict(TypedDict):
+    collect_url: str
+    r"""Expression to derive URL to use for the health check operation (can be a constant)."""
+    type: CollectorHealthCheckType
+    r"""Collector type: health_check"""
+    discovery: NotRequired[CollectorHealthCheckDiscoveryTypedDict]
+    collect_method: NotRequired[HealthCheckMethod]
+    r"""Health check HTTP method."""
+    collect_request_params: NotRequired[Any]
+    collect_body: NotRequired[Any]
+    collect_request_headers: NotRequired[
+        List[CollectorHealthCheckCollectRequestHeaderTypedDict]
+    ]
+    r"""Optional health check request headers."""
+    authenticate_collect: NotRequired[bool]
+    r"""Enable to make auth health check call."""
+    authentication: NotRequired[CollectorHealthCheckAuthentication]
+    r"""Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers."""
+    timeout: NotRequired[float]
+    r"""HTTP request inactivity timeout, use 0 to disable"""
+    reject_unauthorized: NotRequired[bool]
+    r"""Whether to reject certificates that cannot be verified against a valid CA (e.g., self-signed certificates)."""
+    default_breakers: NotRequired[CollectorHealthCheckHiddenDefaultBreakers]
+    safe_headers: NotRequired[List[str]]
+    r"""List of headers that are safe to log in plain text."""
+    retry_rules: NotRequired[CollectorHealthCheckRetryRulesTypedDict]
+
+
+class CollectorHealthCheck(BaseModel):
+    collect_url: Annotated[str, pydantic.Field(alias="collectUrl")]
+    r"""Expression to derive URL to use for the health check operation (can be a constant)."""
+
+    type: CollectorHealthCheckType
+    r"""Collector type: health_check"""
+
+    discovery: Optional[CollectorHealthCheckDiscovery] = None
+
+    collect_method: Annotated[
+        Annotated[
+            Optional[HealthCheckMethod], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="collectMethod"),
+    ] = HealthCheckMethod.GET
+    r"""Health check HTTP method."""
+
+    collect_request_params: Annotated[
+        Optional[Any], pydantic.Field(alias="collectRequestParams")
+    ] = None
+
+    collect_body: Annotated[Optional[Any], pydantic.Field(alias="collectBody")] = None
+
+    collect_request_headers: Annotated[
+        Optional[List[CollectorHealthCheckCollectRequestHeader]],
+        pydantic.Field(alias="collectRequestHeaders"),
+    ] = None
+    r"""Optional health check request headers."""
+
+    authenticate_collect: Annotated[
+        Optional[bool], pydantic.Field(alias="authenticateCollect")
+    ] = False
+    r"""Enable to make auth health check call."""
+
+    authentication: Annotated[
+        Optional[CollectorHealthCheckAuthentication],
+        PlainValidator(validate_open_enum(False)),
+    ] = CollectorHealthCheckAuthentication.NONE
+    r"""Authentication method for Discover and Collect REST calls. You can specify API Key–based authentication by adding the appropriate Collect headers."""
+
+    timeout: Optional[float] = 30
+    r"""HTTP request inactivity timeout, use 0 to disable"""
+
+    reject_unauthorized: Annotated[
+        Optional[bool], pydantic.Field(alias="rejectUnauthorized")
+    ] = False
+    r"""Whether to reject certificates that cannot be verified against a valid CA (e.g., self-signed certificates)."""
+
+    default_breakers: Annotated[
+        Annotated[
+            Optional[CollectorHealthCheckHiddenDefaultBreakers],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="defaultBreakers"),
+    ] = None
+
+    safe_headers: Annotated[
+        Optional[List[str]], pydantic.Field(alias="safeHeaders")
+    ] = None
+    r"""List of headers that are safe to log in plain text."""
+
+    retry_rules: Annotated[
+        Optional[CollectorHealthCheckRetryRules], pydantic.Field(alias="retryRules")
+    ] = None
+
+    @field_serializer("collect_method")
+    def serialize_collect_method(self, value):
+        if isinstance(value, str):
+            try:
+                return models.HealthCheckMethod(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("authentication")
+    def serialize_authentication(self, value):
+        if isinstance(value, str):
+            try:
+                return models.CollectorHealthCheckAuthentication(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("default_breakers")
+    def serialize_default_breakers(self, value):
+        if isinstance(value, str):
+            try:
+                return models.CollectorHealthCheckHiddenDefaultBreakers(value)
+            except ValueError:
+                return value
+        return value