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

cribl_control_plane/models/addhectokenrequest.py

@@ -2,8 +2,9 @@
 
 from __future__ import annotations
 from cribl_control_plane.types import BaseModel
+import pydantic
 from typing import List, Optional
-from typing_extensions import NotRequired, TypedDict
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class AddHecTokenRequestMetadatumTypedDict(TypedDict):
@@ -19,6 +20,7 @@ class AddHecTokenRequestMetadatum(BaseModel):
 
 class AddHecTokenRequestTypedDict(TypedDict):
     token: str
+    allowed_indexes_at_token: NotRequired[List[str]]
     description: NotRequired[str]
     enabled: NotRequired[bool]
     metadata: NotRequired[List[AddHecTokenRequestMetadatumTypedDict]]
@@ -27,6 +29,10 @@ class AddHecTokenRequestTypedDict(TypedDict):
 class AddHecTokenRequest(BaseModel):
     token: str
 
+    allowed_indexes_at_token: Annotated[
+        Optional[List[str]], pydantic.Field(alias="allowedIndexesAtToken")
+    ] = None
+
     description: Optional[str] = None
 
     enabled: Optional[bool] = None

cribl_control_plane/models/authtoken.py

@@ -2,12 +2,16 @@
 
 from __future__ import annotations
 from cribl_control_plane.types import BaseModel
-from typing_extensions import TypedDict
+import pydantic
+from typing_extensions import Annotated, TypedDict
 
 
 class AuthTokenTypedDict(TypedDict):
+    force_password_change: bool
     token: str
 
 
 class AuthToken(BaseModel):
+    force_password_change: Annotated[bool, pydantic.Field(alias="forcePasswordChange")]
+
     token: str

cribl_control_plane/models/backupssettings_union.py

@@ -0,0 +1,37 @@
+"""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 Union
+from typing_extensions import Annotated, TypeAliasType, TypedDict
+
+
+class BackupsSettings2TypedDict(TypedDict):
+    pass
+
+
+class BackupsSettings2(BaseModel):
+    pass
+
+
+class BackupsSettings1TypedDict(TypedDict):
+    backup_persistence: str
+    backups_directory: str
+
+
+class BackupsSettings1(BaseModel):
+    backup_persistence: Annotated[str, pydantic.Field(alias="backupPersistence")]
+
+    backups_directory: Annotated[str, pydantic.Field(alias="backupsDirectory")]
+
+
+BackupsSettingsUnionTypedDict = TypeAliasType(
+    "BackupsSettingsUnionTypedDict",
+    Union[BackupsSettings2TypedDict, BackupsSettings1TypedDict],
+)
+
+
+BackupsSettingsUnion = TypeAliasType(
+    "BackupsSettingsUnion", Union[BackupsSettings2, BackupsSettings1]
+)

cribl_control_plane/models/{lookupversions.py → branchinfo.py}

@@ -5,9 +5,9 @@ from cribl_control_plane.types import BaseModel
 from typing_extensions import TypedDict
 
 
-class LookupVersionsTypedDict(TypedDict):
-    pass
+class BranchInfoTypedDict(TypedDict):
+    id: str
 
 
-class LookupVersions(BaseModel):
-    pass
+class BranchInfo(BaseModel):
+    id: str

cribl_control_plane/models/cacheconnection.py

@@ -3,8 +3,12 @@
 from __future__ import annotations
 from .cacheconnectionbackfillstatus import CacheConnectionBackfillStatus
 from .lakehouseconnectiontype import LakehouseConnectionType
+from cribl_control_plane import models
 from cribl_control_plane.types import BaseModel
+from cribl_control_plane.utils import validate_open_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
 
@@ -31,14 +35,38 @@ class CacheConnection(BaseModel):
     ] = None
 
     backfill_status: Annotated[
-        Optional[CacheConnectionBackfillStatus], pydantic.Field(alias="backfillStatus")
+        Annotated[
+            Optional[CacheConnectionBackfillStatus],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="backfillStatus"),
     ] = None
 
     lakehouse_connection_type: Annotated[
-        Optional[LakehouseConnectionType],
+        Annotated[
+            Optional[LakehouseConnectionType], PlainValidator(validate_open_enum(False))
+        ],
         pydantic.Field(alias="lakehouseConnectionType"),
     ] = None
 
     migration_query_id: Annotated[
         Optional[str], pydantic.Field(alias="migrationQueryId")
     ] = None
+
+    @field_serializer("backfill_status")
+    def serialize_backfill_status(self, value):
+        if isinstance(value, str):
+            try:
+                return models.CacheConnectionBackfillStatus(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("lakehouse_connection_type")
+    def serialize_lakehouse_connection_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.LakehouseConnectionType(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/cacheconnectionbackfillstatus.py

@@ -1,10 +1,11 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from cribl_control_plane import utils
 from enum import Enum
 
 
-class CacheConnectionBackfillStatus(str, Enum):
+class CacheConnectionBackfillStatus(str, Enum, metaclass=utils.OpenEnumMeta):
     SCHEDULED = "scheduled"
     PENDING = "pending"
     STARTED = "started"

cribl_control_plane/models/cloudprovider.py

@@ -1,9 +1,10 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from cribl_control_plane import utils
 from enum import Enum
 
 
-class CloudProvider(str, Enum):
+class CloudProvider(str, Enum, metaclass=utils.OpenEnumMeta):
     AWS = "aws"
     AZURE = "azure"

cribl_control_plane/models/collectorazureblob.py

@@ -0,0 +1,130 @@
+"""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 CollectorAzureBlobType(str, Enum):
+    r"""Collector type: azure_blob"""
+
+    AZURE_BLOB = "azure_blob"
+
+
+class CollectorAzureBlobAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Enter authentication data directly, or select a secret referencing your auth data"""
+
+    MANUAL = "manual"
+    SECRET = "secret"
+    CLIENT_SECRET = "clientSecret"
+    CLIENT_CERT = "clientCert"
+
+
+class CollectorAzureBlobExtractorTypedDict(TypedDict):
+    key: str
+    r"""A token from the template path, such as epoch"""
+    expression: str
+    r"""A JavaScript expression that accesses a corresponding <token> through the value variable and evaluates the token to populate event fields. Example: {date: new Date(+value*1000)}"""
+
+
+class CollectorAzureBlobExtractor(BaseModel):
+    key: str
+    r"""A token from the template path, such as epoch"""
+
+    expression: str
+    r"""A JavaScript expression that accesses a corresponding <token> through the value variable and evaluates the token to populate event fields. Example: {date: new Date(+value*1000)}"""
+
+
+class CollectorAzureBlobTypedDict(TypedDict):
+    type: CollectorAzureBlobType
+    r"""Collector type: azure_blob"""
+    container_name: str
+    r"""Container 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"""An optional predefined Destination that will be used to auto-populate Collector settings"""
+    auth_type: NotRequired[CollectorAzureBlobAuthenticationMethod]
+    r"""Enter authentication data directly, or select a secret referencing your auth data"""
+    path: NotRequired[str]
+    r"""The directory from which to collect data. Templating is supported, such as myDir/${datacenter}/${host}/${app}/. Time-based tokens are supported, such as myOtherDir/${_time:%Y}/${_time:%m}/${_time:%d}/."""
+    extractors: NotRequired[List[CollectorAzureBlobExtractorTypedDict]]
+    r"""Extractors allow use of 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."""
+    recurse: NotRequired[bool]
+    r"""Recurse through subdirectories"""
+    include_metadata: NotRequired[bool]
+    r"""Include Azure Blob metadata in collected events. In each event, metadata will be located at: __collectible.metadata."""
+    include_tags: NotRequired[bool]
+    r"""Include Azure Blob tags in collected events. In each event, tags will be located at: __collectible.tags. Disable this feature when using a Shared Access Signature Connection String, to prevent errors."""
+    max_batch_size: NotRequired[float]
+    r"""Maximum number of metadata objects to batch before recording as results"""
+    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 CollectorAzureBlob(BaseModel):
+    type: CollectorAzureBlobType
+    r"""Collector type: azure_blob"""
+
+    container_name: Annotated[str, pydantic.Field(alias="containerName")]
+    r"""Container 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"""An optional predefined Destination that will be used to auto-populate Collector settings"""
+
+    auth_type: Annotated[
+        Annotated[
+            Optional[CollectorAzureBlobAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
+    ] = CollectorAzureBlobAuthenticationMethod.MANUAL
+    r"""Enter authentication data directly, or select a secret referencing your auth data"""
+
+    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 supported, such as myOtherDir/${_time:%Y}/${_time:%m}/${_time:%d}/."""
+
+    extractors: Optional[List[CollectorAzureBlobExtractor]] = None
+    r"""Extractors allow use of 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."""
+
+    recurse: Optional[bool] = True
+    r"""Recurse through subdirectories"""
+
+    include_metadata: Annotated[
+        Optional[bool], pydantic.Field(alias="includeMetadata")
+    ] = True
+    r"""Include Azure Blob metadata in collected events. In each event, metadata will be located at: __collectible.metadata."""
+
+    include_tags: Annotated[Optional[bool], pydantic.Field(alias="includeTags")] = True
+    r"""Include Azure Blob tags in collected events. In each event, tags will be located at: __collectible.tags. Disable this feature when using a Shared Access Signature Connection String, to prevent errors."""
+
+    max_batch_size: Annotated[Optional[float], pydantic.Field(alias="maxBatchSize")] = (
+        10
+    )
+    r"""Maximum number of metadata objects to batch before recording as results"""
+
+    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.CollectorAzureBlobAuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/collectorconf.py

@@ -0,0 +1,56 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .collectorazureblob import CollectorAzureBlob, CollectorAzureBlobTypedDict
+from .collectorcribllake import CollectorCriblLake, CollectorCriblLakeTypedDict
+from .collectordatabase import CollectorDatabase, CollectorDatabaseTypedDict
+from .collectorfilesystem import CollectorFilesystem, CollectorFilesystemTypedDict
+from .collectorgooglecloudstorage import (
+    CollectorGoogleCloudStorage,
+    CollectorGoogleCloudStorageTypedDict,
+)
+from .collectorhealthcheck import CollectorHealthCheck, CollectorHealthCheckTypedDict
+from .collectorrest import CollectorRest, CollectorRestTypedDict
+from .collectors3 import CollectorS3, CollectorS3TypedDict
+from .collectorscript import CollectorScript, CollectorScriptTypedDict
+from .collectorsplunk import CollectorSplunk, CollectorSplunkTypedDict
+from cribl_control_plane.utils import get_discriminator
+from pydantic import Discriminator, Tag
+from typing import Union
+from typing_extensions import Annotated, TypeAliasType
+
+
+CollectorConfTypedDict = TypeAliasType(
+    "CollectorConfTypedDict",
+    Union[
+        CollectorCriblLakeTypedDict,
+        CollectorScriptTypedDict,
+        CollectorDatabaseTypedDict,
+        CollectorFilesystemTypedDict,
+        CollectorAzureBlobTypedDict,
+        CollectorGoogleCloudStorageTypedDict,
+        CollectorHealthCheckTypedDict,
+        CollectorSplunkTypedDict,
+        CollectorRestTypedDict,
+        CollectorS3TypedDict,
+    ],
+)
+r"""Collector configuration"""
+
+
+CollectorConf = Annotated[
+    Union[
+        Annotated[CollectorAzureBlob, Tag("azure_blob")],
+        Annotated[CollectorCriblLake, Tag("cribl_lake")],
+        Annotated[CollectorDatabase, Tag("database")],
+        Annotated[CollectorFilesystem, Tag("filesystem")],
+        Annotated[CollectorGoogleCloudStorage, Tag("google_cloud_storage")],
+        Annotated[CollectorHealthCheck, Tag("health_check")],
+        Annotated[CollectorRest, Tag("rest")],
+        Annotated[CollectorS3, Tag("s3")],
+        Annotated[CollectorScript, Tag("script")],
+        Annotated[CollectorSplunk, Tag("splunk")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+r"""Collector configuration"""

cribl_control_plane/models/collectorcribllake.py

@@ -0,0 +1,27 @@
+"""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
+from typing_extensions import TypedDict
+
+
+class CollectorCriblLakeType(str, Enum):
+    r"""Collector type: cribl_lake"""
+
+    CRIBL_LAKE = "cribl_lake"
+
+
+class CollectorCriblLakeTypedDict(TypedDict):
+    type: CollectorCriblLakeType
+    r"""Collector type: cribl_lake"""
+    dataset: str
+    r"""Lake dataset to collect data from."""
+
+
+class CollectorCriblLake(BaseModel):
+    type: CollectorCriblLakeType
+    r"""Collector type: cribl_lake"""
+
+    dataset: str
+    r"""Lake dataset to collect data from."""

cribl_control_plane/models/collectordatabase.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 Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class CollectorDatabaseType(str, Enum):
+    r"""Collector type: database"""
+
+    DATABASE = "database"
+
+
+class CollectorDatabaseHiddenDefaultBreakers(str, Enum, metaclass=utils.OpenEnumMeta):
+    CRIBL = "Cribl"
+
+
+class CollectorDatabaseStateTrackingTypedDict(TypedDict):
+    enabled: NotRequired[bool]
+    r"""Enable tracking of collection progress between consecutive scheduled executions."""
+
+
+class CollectorDatabaseStateTracking(BaseModel):
+    enabled: Optional[bool] = None
+    r"""Enable tracking of collection progress between consecutive scheduled executions."""
+
+
+class CollectorDatabaseSchedulingTypedDict(TypedDict):
+    state_tracking: NotRequired[CollectorDatabaseStateTrackingTypedDict]
+
+
+class CollectorDatabaseScheduling(BaseModel):
+    state_tracking: Annotated[
+        Optional[CollectorDatabaseStateTracking], pydantic.Field(alias="stateTracking")
+    ] = None
+
+
+class CollectorDatabaseTypedDict(TypedDict):
+    type: CollectorDatabaseType
+    r"""Collector type: database"""
+    connection_id: str
+    r"""Select an existing Connection, or go to Knowledge > Database Connections to add one"""
+    query: str
+    r"""An expression that resolves to the query string for selecting data from the database. Has access to the special ${earliest} and ${latest} variables, which will resolve to the Collector run's start and end time."""
+    query_validation_enabled: NotRequired[bool]
+    r"""Enforces a basic query validation that allows only a single 'select' statement. Disable for more complex queries or when using semicolons. Caution: Disabling query validation allows DDL and DML statements to be executed, which could be destructive to your database."""
+    default_breakers: NotRequired[CollectorDatabaseHiddenDefaultBreakers]
+    scheduling: NotRequired[CollectorDatabaseSchedulingTypedDict]
+
+
+class CollectorDatabase(BaseModel):
+    type: CollectorDatabaseType
+    r"""Collector type: database"""
+
+    connection_id: Annotated[str, pydantic.Field(alias="connectionId")]
+    r"""Select an existing Connection, or go to Knowledge > Database Connections to add one"""
+
+    query: str
+    r"""An expression that resolves to the query string for selecting data from the database. Has access to the special ${earliest} and ${latest} variables, which will resolve to the Collector run's start and end time."""
+
+    query_validation_enabled: Annotated[
+        Optional[bool], pydantic.Field(alias="queryValidationEnabled")
+    ] = True
+    r"""Enforces a basic query validation that allows only a single 'select' statement. Disable for more complex queries or when using semicolons. Caution: Disabling query validation allows DDL and DML statements to be executed, which could be destructive to your database."""
+
+    default_breakers: Annotated[
+        Annotated[
+            Optional[CollectorDatabaseHiddenDefaultBreakers],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="defaultBreakers"),
+    ] = None
+
+    scheduling: Annotated[
+        Optional[CollectorDatabaseScheduling], pydantic.Field(alias="__scheduling")
+    ] = None
+
+    @field_serializer("default_breakers")
+    def serialize_default_breakers(self, value):
+        if isinstance(value, str):
+            try:
+                return models.CollectorDatabaseHiddenDefaultBreakers(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/collectorfilesystem.py

@@ -0,0 +1,66 @@
+"""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 List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class CollectorFilesystemType(str, Enum):
+    r"""Collector type: filesystem"""
+
+    FILESYSTEM = "filesystem"
+
+
+class CollectorFilesystemExtractorTypedDict(TypedDict):
+    key: str
+    r"""A token from the template directory, 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 CollectorFilesystemExtractor(BaseModel):
+    key: str
+    r"""A token from the template directory, 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 CollectorFilesystemTypedDict(TypedDict):
+    type: CollectorFilesystemType
+    r"""Collector type: filesystem"""
+    path: 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}/."""
+    output_name: NotRequired[str]
+    r"""Select a predefined configuration (a Destination) to auto-populate Collector settings"""
+    extractors: NotRequired[List[CollectorFilesystemExtractorTypedDict]]
+    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."""
+    recurse: NotRequired[bool]
+    r"""Recurse through subdirectories"""
+    max_batch_size: NotRequired[float]
+    r"""Maximum number of metadata files to batch before recording as results"""
+
+
+class CollectorFilesystem(BaseModel):
+    type: CollectorFilesystemType
+    r"""Collector type: filesystem"""
+
+    path: 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}/."""
+
+    output_name: Annotated[Optional[str], pydantic.Field(alias="outputName")] = None
+    r"""Select a predefined configuration (a Destination) to auto-populate Collector settings"""
+
+    extractors: Optional[List[CollectorFilesystemExtractor]] = 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."""
+
+    recurse: Optional[bool] = True
+    r"""Recurse through subdirectories"""
+
+    max_batch_size: Annotated[Optional[float], pydantic.Field(alias="maxBatchSize")] = (
+        10
+    )
+    r"""Maximum number of metadata files to batch before recording as results"""