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

cribl_control_plane/models/collectorrest.py

@@ -0,0 +1,340 @@
+"""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 CollectorRestType(str, Enum):
+    r"""Collector type: rest"""
+
+    REST = "rest"
+
+
+class CollectorRestDiscoverType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Defines how task discovery will be performed. Each entry returned by the Discover operation will result in a Collect task."""
+
+    HTTP = "http"
+    JSON = "json"
+    LIST = "list"
+    NONE = "none"
+
+
+class CollectorRestDiscoveryTypedDict(TypedDict):
+    discover_type: NotRequired[CollectorRestDiscoverType]
+    r"""Defines how task discovery will be performed. Each entry returned by the Discover operation will result in a Collect task."""
+
+
+class CollectorRestDiscovery(BaseModel):
+    discover_type: Annotated[
+        Annotated[
+            Optional[CollectorRestDiscoverType],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="discoverType"),
+    ] = CollectorRestDiscoverType.NONE
+    r"""Defines how task discovery will be performed. 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.CollectorRestDiscoverType(value)
+            except ValueError:
+                return value
+        return value
+
+
+class CollectMethod(str, Enum, metaclass=utils.OpenEnumMeta):
+    # GET
+    GET = "get"
+    # POST
+    POST = "post"
+    # POST with Body
+    POST_WITH_BODY = "post_with_body"
+    # Other
+    OTHER = "other"
+
+
+class CollectorRestCollectRequestHeaderTypedDict(TypedDict):
+    name: str
+    value: str
+    r"""JavaScript expression to compute parameter value, usually enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values that aren't successfully evaluated as JavaScript expressions will be treated as string constants."""
+
+
+class CollectorRestCollectRequestHeader(BaseModel):
+    name: str
+
+    value: str
+    r"""JavaScript expression to compute parameter value, usually enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values that aren't successfully evaluated as JavaScript expressions will be treated as string constants."""
+
+
+class PaginationEnum(str, Enum, metaclass=utils.OpenEnumMeta):
+    # None
+    NONE = "none"
+    # Response Body Attribute
+    RESPONSE_BODY = "response_body"
+    # Response Header Attribute
+    RESPONSE_HEADER = "response_header"
+    # RFC 5988 - Web Linking
+    RESPONSE_HEADER_LINK = "response_header_link"
+    # Offset/Limit
+    REQUEST_OFFSET = "request_offset"
+    # Page/Size
+    REQUEST_PAGE = "request_page"
+
+
+class PaginationTypedDict(TypedDict):
+    type: NotRequired[PaginationEnum]
+
+
+class Pagination(BaseModel):
+    type: Annotated[
+        Optional[PaginationEnum], PlainValidator(validate_open_enum(False))
+    ] = PaginationEnum.NONE
+
+    @field_serializer("type")
+    def serialize_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.PaginationEnum(value)
+            except ValueError:
+                return value
+        return value
+
+
+class CollectorRestAuthentication(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"
+    GOOGLE_OAUTH = "google_oauth"
+    GOOGLE_OAUTH_SECRET = "google_oauthSecret"
+    HMAC = "hmac"
+
+
+class CollectorRestRetryType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Algorithm to use when performing HTTP retries"""
+
+    # Disabled
+    NONE = "none"
+    # Backoff
+    BACKOFF = "backoff"
+    # Static
+    STATIC = "static"
+
+
+class CollectorRestRetryRulesTypedDict(TypedDict):
+    type: NotRequired[CollectorRestRetryType]
+    r"""Algorithm to use when performing HTTP retries"""
+    interval: NotRequired[Any]
+    limit: NotRequired[Any]
+    multiplier: NotRequired[Any]
+    max_interval_ms: NotRequired[Any]
+    codes: NotRequired[Any]
+    enable_header: NotRequired[Any]
+    retry_connect_timeout: NotRequired[Any]
+    retry_connect_reset: NotRequired[Any]
+
+
+class CollectorRestRetryRules(BaseModel):
+    type: Annotated[
+        Optional[CollectorRestRetryType], PlainValidator(validate_open_enum(False))
+    ] = CollectorRestRetryType.BACKOFF
+    r"""Algorithm to use when performing HTTP retries"""
+
+    interval: Optional[Any] = None
+
+    limit: Optional[Any] = None
+
+    multiplier: Optional[Any] = None
+
+    max_interval_ms: Annotated[Optional[Any], pydantic.Field(alias="maxIntervalMs")] = (
+        None
+    )
+
+    codes: Optional[Any] = None
+
+    enable_header: Annotated[Optional[Any], pydantic.Field(alias="enableHeader")] = None
+
+    retry_connect_timeout: Annotated[
+        Optional[Any], pydantic.Field(alias="retryConnectTimeout")
+    ] = None
+
+    retry_connect_reset: Annotated[
+        Optional[Any], pydantic.Field(alias="retryConnectReset")
+    ] = None
+
+    @field_serializer("type")
+    def serialize_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.CollectorRestRetryType(value)
+            except ValueError:
+                return value
+        return value
+
+
+class CollectorRestStateTrackingTypedDict(TypedDict):
+    enabled: NotRequired[bool]
+    r"""Track collection progress between consecutive scheduled executions"""
+
+
+class CollectorRestStateTracking(BaseModel):
+    enabled: Optional[bool] = None
+    r"""Track collection progress between consecutive scheduled executions"""
+
+
+class CollectorRestSchedulingTypedDict(TypedDict):
+    state_tracking: NotRequired[CollectorRestStateTrackingTypedDict]
+
+
+class CollectorRestScheduling(BaseModel):
+    state_tracking: Annotated[
+        Optional[CollectorRestStateTracking], pydantic.Field(alias="stateTracking")
+    ] = None
+
+
+class CollectorRestTypedDict(TypedDict):
+    type: CollectorRestType
+    r"""Collector type: rest"""
+    collect_url: str
+    r"""URL (constant or JavaScript expression) to use for the Collect operation"""
+    discovery: NotRequired[CollectorRestDiscoveryTypedDict]
+    collect_method: NotRequired[CollectMethod]
+    collect_verb: NotRequired[Any]
+    collect_request_params: NotRequired[Any]
+    collect_body: NotRequired[Any]
+    collect_request_headers: NotRequired[
+        List[CollectorRestCollectRequestHeaderTypedDict]
+    ]
+    pagination: NotRequired[PaginationTypedDict]
+    authentication: NotRequired[CollectorRestAuthentication]
+    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."""
+    use_round_robin_dns: NotRequired[bool]
+    r"""Use round-robin DNS lookup. Suitable when DNS server returns multiple addresses in sort order."""
+    disable_time_filter: NotRequired[bool]
+    r"""Disable Collector event time filtering when a date range is specified"""
+    decode_url: NotRequired[bool]
+    r"""Decode the URL before sending requests (including pagination requests)"""
+    reject_unauthorized: NotRequired[bool]
+    r"""Reject certificates that cannot be verified against a valid CA (such as self-signed certificates)"""
+    capture_headers: NotRequired[bool]
+    r"""Enable to add response headers to the resHeaders field under the __collectible object"""
+    stop_on_empty_results: NotRequired[bool]
+    r"""Stop pagination when the Event Breaker produces no events"""
+    safe_headers: NotRequired[List[str]]
+    r"""List of headers that are safe to log in plain text"""
+    retry_rules: NotRequired[CollectorRestRetryRulesTypedDict]
+    scheduling: NotRequired[CollectorRestSchedulingTypedDict]
+
+
+class CollectorRest(BaseModel):
+    type: CollectorRestType
+    r"""Collector type: rest"""
+
+    collect_url: Annotated[str, pydantic.Field(alias="collectUrl")]
+    r"""URL (constant or JavaScript expression) to use for the Collect operation"""
+
+    discovery: Optional[CollectorRestDiscovery] = None
+
+    collect_method: Annotated[
+        Annotated[Optional[CollectMethod], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="collectMethod"),
+    ] = CollectMethod.GET
+
+    collect_verb: Annotated[Optional[Any], pydantic.Field(alias="collectVerb")] = None
+
+    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[CollectorRestCollectRequestHeader]],
+        pydantic.Field(alias="collectRequestHeaders"),
+    ] = None
+
+    pagination: Optional[Pagination] = None
+
+    authentication: Annotated[
+        Optional[CollectorRestAuthentication], PlainValidator(validate_open_enum(False))
+    ] = CollectorRestAuthentication.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] = 0
+    r"""HTTP request inactivity timeout. Use 0 to disable."""
+
+    use_round_robin_dns: Annotated[
+        Optional[bool], pydantic.Field(alias="useRoundRobinDns")
+    ] = False
+    r"""Use round-robin DNS lookup. Suitable when DNS server returns multiple addresses in sort order."""
+
+    disable_time_filter: Annotated[
+        Optional[bool], pydantic.Field(alias="disableTimeFilter")
+    ] = False
+    r"""Disable Collector event time filtering when a date range is specified"""
+
+    decode_url: Annotated[Optional[bool], pydantic.Field(alias="decodeUrl")] = True
+    r"""Decode the URL before sending requests (including pagination requests)"""
+
+    reject_unauthorized: Annotated[
+        Optional[bool], pydantic.Field(alias="rejectUnauthorized")
+    ] = False
+    r"""Reject certificates that cannot be verified against a valid CA (such as self-signed certificates)"""
+
+    capture_headers: Annotated[
+        Optional[bool], pydantic.Field(alias="captureHeaders")
+    ] = False
+    r"""Enable to add response headers to the resHeaders field under the __collectible object"""
+
+    stop_on_empty_results: Annotated[
+        Optional[bool], pydantic.Field(alias="stopOnEmptyResults")
+    ] = False
+    r"""Stop pagination when the Event Breaker produces no events"""
+
+    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[CollectorRestRetryRules], pydantic.Field(alias="retryRules")
+    ] = None
+
+    scheduling: Annotated[
+        Optional[CollectorRestScheduling], pydantic.Field(alias="__scheduling")
+    ] = None
+
+    @field_serializer("collect_method")
+    def serialize_collect_method(self, value):
+        if isinstance(value, str):
+            try:
+                return models.CollectMethod(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("authentication")
+    def serialize_authentication(self, value):
+        if isinstance(value, str):
+            try:
+                return models.CollectorRestAuthentication(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/collectors3.py

@@ -0,0 +1,239 @@
+"""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 CollectorS3Type(str, Enum):
+    r"""Collector type: s3"""
+
+    S3 = "s3"
+
+
+class PartitioningScheme(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval."""
+
+    # Defined in Path
+    NONE = "none"
+    # DDSS
+    DDSS = "ddss"
+
+
+class CollectorS3ExtractorTypedDict(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. Example: {date: new Date(+value*1000)}"""
+
+
+class CollectorS3Extractor(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. Example: {date: new Date(+value*1000)}"""
+
+
+class CollectorS3AuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""AWS authentication method. Choose Auto to use IAM roles."""
+
+    # Auto
+    AUTO = "auto"
+    # Manual
+    MANUAL = "manual"
+    # Secret Key pair
+    SECRET = "secret"
+
+
+class CollectorS3SignatureVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Signature version to use for signing S3 requests"""
+
+    V2 = "v2"
+    V4 = "v4"
+
+
+class CollectorS3TypedDict(TypedDict):
+    type: CollectorS3Type
+    r"""Collector type: s3"""
+    bucket: str
+    r"""S3 Bucket from which to collect data"""
+    output_name: NotRequired[str]
+    r"""Name of the predefined Destination that will be used to auto-populate Collector settings"""
+    parquet_chunk_size_mb: NotRequired[float]
+    r"""Maximum file size for each Parquet chunk"""
+    parquet_chunk_download_timeout: NotRequired[float]
+    r"""Maximum time allowed for downloading a Parquet chunk. Processing will stop if a chunk cannot be downloaded within the time specified."""
+    region: NotRequired[str]
+    r"""Region from which to retrieve data"""
+    path: NotRequired[str]
+    r"""Directory where data will be collected. Templating (such as 'myDir/${datacenter}/${host}/${app}/') and time-based tokens (such as 'myOtherDir/${_time:%Y}/${_time:%m}/${_time:%d}/') are supported. Can be a constant (enclosed in quotes) or a JavaScript expression."""
+    partitioning_scheme: NotRequired[PartitioningScheme]
+    r"""Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval."""
+    extractors: NotRequired[List[CollectorS3ExtractorTypedDict]]
+    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."""
+    aws_authentication_method: NotRequired[CollectorS3AuthenticationMethod]
+    r"""AWS authentication method. Choose Auto to use IAM roles."""
+    endpoint: NotRequired[str]
+    r"""Must point to an S3-compatible endpoint. If empty, defaults to an AWS region-specific endpoint."""
+    signature_version: NotRequired[CollectorS3SignatureVersion]
+    r"""Signature version to use for signing S3 requests"""
+    enable_assume_role: NotRequired[bool]
+    r"""Use AssumeRole credentials"""
+    assume_role_arn: NotRequired[str]
+    r"""Amazon Resource Name (ARN) of the role to assume"""
+    assume_role_external_id: NotRequired[str]
+    r"""External ID to use when assuming role"""
+    duration_seconds: NotRequired[float]
+    r"""Duration of the Assumed Role's session, in seconds. Minimum is 900 (15 minutes), default is 3600 (1 hour), and maximum is 43200 (12 hours)."""
+    max_batch_size: NotRequired[float]
+    r"""Maximum number of metadata objects to batch before recording as results"""
+    recurse: NotRequired[Any]
+    reuse_connections: NotRequired[bool]
+    r"""Reuse connections between requests to improve performance"""
+    reject_unauthorized: NotRequired[bool]
+    r"""Reject certificates that cannot be verified against a valid CA (such as a self-signed certificate)"""
+    verify_permissions: NotRequired[bool]
+    r"""Disable if you can access files within the bucket but not the bucket itself. Resolves errors of the form \"discover task initialization failed...error: Forbidden\"."""
+    disable_time_filter: NotRequired[bool]
+    r"""Disable Collector event time filtering when a date range is specified"""
+
+
+class CollectorS3(BaseModel):
+    type: CollectorS3Type
+    r"""Collector type: s3"""
+
+    bucket: str
+    r"""S3 Bucket from which to collect data"""
+
+    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"""
+
+    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"""Maximum time allowed for downloading a Parquet chunk. Processing will stop if a chunk cannot be downloaded within the time specified."""
+
+    region: Optional[str] = None
+    r"""Region from which to retrieve data"""
+
+    path: Optional[str] = None
+    r"""Directory where data will be collected. Templating (such as 'myDir/${datacenter}/${host}/${app}/') and time-based tokens (such as 'myOtherDir/${_time:%Y}/${_time:%m}/${_time:%d}/') are supported. Can be a constant (enclosed in quotes) or a JavaScript expression."""
+
+    partitioning_scheme: Annotated[
+        Annotated[
+            Optional[PartitioningScheme], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="partitioningScheme"),
+    ] = PartitioningScheme.NONE
+    r"""Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval."""
+
+    extractors: Optional[List[CollectorS3Extractor]] = 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."""
+
+    aws_authentication_method: Annotated[
+        Annotated[
+            Optional[CollectorS3AuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="awsAuthenticationMethod"),
+    ] = CollectorS3AuthenticationMethod.AUTO
+    r"""AWS authentication method. Choose Auto to use IAM roles."""
+
+    endpoint: Optional[str] = None
+    r"""Must point to an S3-compatible endpoint. If empty, defaults to an AWS region-specific endpoint."""
+
+    signature_version: Annotated[
+        Annotated[
+            Optional[CollectorS3SignatureVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="signatureVersion"),
+    ] = CollectorS3SignatureVersion.V4
+    r"""Signature version to use for signing S3 requests"""
+
+    enable_assume_role: Annotated[
+        Optional[bool], pydantic.Field(alias="enableAssumeRole")
+    ] = False
+    r"""Use AssumeRole credentials"""
+
+    assume_role_arn: Annotated[Optional[str], pydantic.Field(alias="assumeRoleArn")] = (
+        None
+    )
+    r"""Amazon Resource Name (ARN) of the role to assume"""
+
+    assume_role_external_id: Annotated[
+        Optional[str], pydantic.Field(alias="assumeRoleExternalId")
+    ] = None
+    r"""External ID to use when assuming role"""
+
+    duration_seconds: Annotated[
+        Optional[float], pydantic.Field(alias="durationSeconds")
+    ] = 3600
+    r"""Duration of the Assumed Role's session, in seconds. Minimum is 900 (15 minutes), default is 3600 (1 hour), and maximum is 43200 (12 hours)."""
+
+    max_batch_size: Annotated[Optional[float], pydantic.Field(alias="maxBatchSize")] = (
+        10
+    )
+    r"""Maximum number of metadata objects to batch before recording as results"""
+
+    recurse: Optional[Any] = None
+
+    reuse_connections: Annotated[
+        Optional[bool], pydantic.Field(alias="reuseConnections")
+    ] = True
+    r"""Reuse connections between requests to improve performance"""
+
+    reject_unauthorized: Annotated[
+        Optional[bool], pydantic.Field(alias="rejectUnauthorized")
+    ] = True
+    r"""Reject certificates that cannot be verified against a valid CA (such as a self-signed certificate)"""
+
+    verify_permissions: Annotated[
+        Optional[bool], pydantic.Field(alias="verifyPermissions")
+    ] = True
+    r"""Disable if you can access files within the bucket but not the bucket itself. Resolves errors of the form \"discover task initialization failed...error: Forbidden\"."""
+
+    disable_time_filter: Annotated[
+        Optional[bool], pydantic.Field(alias="disableTimeFilter")
+    ] = False
+    r"""Disable Collector event time filtering when a date range is specified"""
+
+    @field_serializer("partitioning_scheme")
+    def serialize_partitioning_scheme(self, value):
+        if isinstance(value, str):
+            try:
+                return models.PartitioningScheme(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("aws_authentication_method")
+    def serialize_aws_authentication_method(self, value):
+        if isinstance(value, str):
+            try:
+                return models.CollectorS3AuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("signature_version")
+    def serialize_signature_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.CollectorS3SignatureVersion(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/collectorscript.py

@@ -0,0 +1,59 @@
+"""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 CollectorScriptType(str, Enum):
+    r"""Collector type: script"""
+
+    SCRIPT = "script"
+
+
+class EnvVarTypedDict(TypedDict):
+    name: str
+    r"""Environment variable name"""
+    value: str
+    r"""JavaScript expression to compute environment variable's value, enclosed in quotes or backticks. (Can evaluate to a constant.)"""
+
+
+class EnvVar(BaseModel):
+    name: str
+    r"""Environment variable name"""
+
+    value: str
+    r"""JavaScript expression to compute environment variable's value, enclosed in quotes or backticks. (Can evaluate to a constant.)"""
+
+
+class CollectorScriptTypedDict(TypedDict):
+    type: CollectorScriptType
+    r"""Collector type: script"""
+    discover_script: str
+    r"""Script to discover what to collect. Should output one task per line in stdout."""
+    collect_script: str
+    r"""Script to run to perform data collections. Task passed in as $CRIBL_COLLECT_ARG. Should output results to stdout."""
+    shell: NotRequired[str]
+    r"""Shell to use to execute scripts."""
+    env_vars: NotRequired[List[EnvVarTypedDict]]
+    r"""Environment variables to expose to the discover and collect scripts."""
+
+
+class CollectorScript(BaseModel):
+    type: CollectorScriptType
+    r"""Collector type: script"""
+
+    discover_script: Annotated[str, pydantic.Field(alias="discoverScript")]
+    r"""Script to discover what to collect. Should output one task per line in stdout."""
+
+    collect_script: Annotated[str, pydantic.Field(alias="collectScript")]
+    r"""Script to run to perform data collections. Task passed in as $CRIBL_COLLECT_ARG. Should output results to stdout."""
+
+    shell: Optional[str] = "/bin/bash"
+    r"""Shell to use to execute scripts."""
+
+    env_vars: Annotated[Optional[List[EnvVar]], pydantic.Field(alias="envVars")] = None
+    r"""Environment variables to expose to the discover and collect scripts."""