cribl-control-plane 0.2.1rc7__py3-none-any.whl → 0.3.0a1__py3-none-any.whl

cribl_control_plane/models/groupcreaterequest.py

@@ -1,171 +0,0 @@
-"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
-
-from __future__ import annotations
-from .commit import Commit, CommitTypedDict
-from .configgroupcloud import ConfigGroupCloud, ConfigGroupCloudTypedDict
-from .configgrouplookups import ConfigGroupLookups, ConfigGroupLookupsTypedDict
-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 GroupCreateRequestEstimatedIngestRate(int, Enum, metaclass=utils.OpenEnumMeta):
-    r"""Maximum expected volume of data ingested by the @{group}. (This setting is available only on @{group}s consisting of Cribl-managed Cribl.Cloud @{node}s.)"""
-
-    # 12 MB/sec
-    RATE12_MB_PER_SEC = 1024
-    # 24 MB/sec
-    RATE24_MB_PER_SEC = 2048
-    # 36 MB/sec
-    RATE36_MB_PER_SEC = 3072
-    # 48 MB/sec
-    RATE48_MB_PER_SEC = 4096
-    # 60 MB/sec
-    RATE60_MB_PER_SEC = 5120
-    # 84 MB/sec
-    RATE84_MB_PER_SEC = 7168
-    # 120 MB/sec
-    RATE120_MB_PER_SEC = 10240
-    # 156 MB/sec
-    RATE156_MB_PER_SEC = 13312
-    # 180 MB/sec
-    RATE180_MB_PER_SEC = 15360
-
-
-class GroupCreateRequestGitTypedDict(TypedDict):
-    commit: NotRequired[str]
-    local_changes: NotRequired[float]
-    log: NotRequired[List[CommitTypedDict]]
-
-
-class GroupCreateRequestGit(BaseModel):
-    commit: Optional[str] = None
-
-    local_changes: Annotated[Optional[float], pydantic.Field(alias="localChanges")] = (
-        None
-    )
-
-    log: Optional[List[Commit]] = None
-
-
-class GroupCreateRequestType(str, Enum, metaclass=utils.OpenEnumMeta):
-    LAKE_ACCESS = "lake_access"
-
-
-class GroupCreateRequestTypedDict(TypedDict):
-    id: str
-    cloud: NotRequired[ConfigGroupCloudTypedDict]
-    deploying_worker_count: NotRequired[float]
-    description: NotRequired[str]
-    estimated_ingest_rate: NotRequired[GroupCreateRequestEstimatedIngestRate]
-    r"""Maximum expected volume of data ingested by the @{group}. (This setting is available only on @{group}s consisting of Cribl-managed Cribl.Cloud @{node}s.)"""
-    git: NotRequired[GroupCreateRequestGitTypedDict]
-    incompatible_worker_count: NotRequired[float]
-    inherits: NotRequired[str]
-    is_fleet: NotRequired[bool]
-    is_search: NotRequired[bool]
-    lookup_deployments: NotRequired[List[ConfigGroupLookupsTypedDict]]
-    max_worker_age: NotRequired[str]
-    name: NotRequired[str]
-    on_prem: NotRequired[bool]
-    provisioned: NotRequired[bool]
-    source_group_id: NotRequired[str]
-    streamtags: NotRequired[List[str]]
-    tags: NotRequired[str]
-    type: NotRequired[GroupCreateRequestType]
-    upgrade_version: NotRequired[str]
-    worker_count: NotRequired[float]
-    worker_remote_access: NotRequired[bool]
-
-
-class GroupCreateRequest(BaseModel):
-    id: str
-
-    cloud: Optional[ConfigGroupCloud] = None
-
-    deploying_worker_count: Annotated[
-        Optional[float], pydantic.Field(alias="deployingWorkerCount")
-    ] = None
-
-    description: Optional[str] = None
-
-    estimated_ingest_rate: Annotated[
-        Annotated[
-            Optional[GroupCreateRequestEstimatedIngestRate],
-            PlainValidator(validate_open_enum(True)),
-        ],
-        pydantic.Field(alias="estimatedIngestRate"),
-    ] = None
-    r"""Maximum expected volume of data ingested by the @{group}. (This setting is available only on @{group}s consisting of Cribl-managed Cribl.Cloud @{node}s.)"""
-
-    git: Optional[GroupCreateRequestGit] = None
-
-    incompatible_worker_count: Annotated[
-        Optional[float], pydantic.Field(alias="incompatibleWorkerCount")
-    ] = None
-
-    inherits: Optional[str] = None
-
-    is_fleet: Annotated[Optional[bool], pydantic.Field(alias="isFleet")] = None
-
-    is_search: Annotated[Optional[bool], pydantic.Field(alias="isSearch")] = None
-
-    lookup_deployments: Annotated[
-        Optional[List[ConfigGroupLookups]], pydantic.Field(alias="lookupDeployments")
-    ] = None
-
-    max_worker_age: Annotated[Optional[str], pydantic.Field(alias="maxWorkerAge")] = (
-        None
-    )
-
-    name: Optional[str] = None
-
-    on_prem: Annotated[Optional[bool], pydantic.Field(alias="onPrem")] = None
-
-    provisioned: Optional[bool] = None
-
-    source_group_id: Annotated[Optional[str], pydantic.Field(alias="sourceGroupId")] = (
-        None
-    )
-
-    streamtags: Optional[List[str]] = None
-
-    tags: Optional[str] = None
-
-    type: Annotated[
-        Optional[GroupCreateRequestType], PlainValidator(validate_open_enum(False))
-    ] = None
-
-    upgrade_version: Annotated[
-        Optional[str], pydantic.Field(alias="upgradeVersion")
-    ] = None
-
-    worker_count: Annotated[Optional[float], pydantic.Field(alias="workerCount")] = None
-
-    worker_remote_access: Annotated[
-        Optional[bool], pydantic.Field(alias="workerRemoteAccess")
-    ] = None
-
-    @field_serializer("estimated_ingest_rate")
-    def serialize_estimated_ingest_rate(self, value):
-        if isinstance(value, str):
-            try:
-                return models.GroupCreateRequestEstimatedIngestRate(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("type")
-    def serialize_type(self, value):
-        if isinstance(value, str):
-            try:
-                return models.GroupCreateRequestType(value)
-            except ValueError:
-                return value
-        return value

cribl_control_plane/models/outpostnodeinfo.py

@@ -1,16 +0,0 @@
-"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
-
-from __future__ import annotations
-from cribl_control_plane.types import BaseModel
-from typing_extensions import TypedDict
-
-
-class OutpostNodeInfoTypedDict(TypedDict):
-    guid: str
-    host: str
-
-
-class OutpostNodeInfo(BaseModel):
-    guid: str
-
-    host: str

cribl_control_plane/models/outputdatabricks.py

@@ -1,482 +0,0 @@
-"""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 OutputDatabricksType(str, Enum):
-    DATABRICKS = "databricks"
-
-
-class OutputDatabricksDataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""Format of the output data"""
-
-    # JSON
-    JSON = "json"
-    # Raw
-    RAW = "raw"
-    # Parquet
-    PARQUET = "parquet"
-
-
-class OutputDatabricksBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""How to handle events when all receivers are exerting backpressure"""
-
-    # Block
-    BLOCK = "block"
-    # Drop
-    DROP = "drop"
-
-
-class OutputDatabricksDiskSpaceProtection(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
-
-    # Block
-    BLOCK = "block"
-    # Drop
-    DROP = "drop"
-
-
-class OutputDatabricksCompression(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""Data compression format to apply to HTTP content before it is delivered"""
-
-    NONE = "none"
-    GZIP = "gzip"
-
-
-class OutputDatabricksCompressionLevel(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""Compression level to apply before moving files to final destination"""
-
-    # Best Speed
-    BEST_SPEED = "best_speed"
-    # Normal
-    NORMAL = "normal"
-    # Best Compression
-    BEST_COMPRESSION = "best_compression"
-
-
-class OutputDatabricksParquetVersion(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""Determines which data types are supported and how they are represented"""
-
-    # 1.0
-    PARQUET_1_0 = "PARQUET_1_0"
-    # 2.4
-    PARQUET_2_4 = "PARQUET_2_4"
-    # 2.6
-    PARQUET_2_6 = "PARQUET_2_6"
-
-
-class OutputDatabricksDataPageVersion(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""Serialization format of data pages. Note that some reader implementations use Data page V2's attributes to work more efficiently, while others ignore it."""
-
-    # V1
-    DATA_PAGE_V1 = "DATA_PAGE_V1"
-    # V2
-    DATA_PAGE_V2 = "DATA_PAGE_V2"
-
-
-class OutputDatabricksKeyValueMetadatumTypedDict(TypedDict):
-    value: str
-    key: NotRequired[str]
-
-
-class OutputDatabricksKeyValueMetadatum(BaseModel):
-    value: str
-
-    key: Optional[str] = ""
-
-
-class OutputDatabricksTypedDict(TypedDict):
-    type: OutputDatabricksType
-    workspace_id: str
-    r"""Databricks workspace ID"""
-    client_id: str
-    r"""OAuth client ID for Unity Catalog authentication"""
-    client_secret: str
-    r"""OAuth client secret for Unity Catalog authentication"""
-    id: NotRequired[str]
-    r"""Unique ID for this output"""
-    pipeline: NotRequired[str]
-    r"""Pipeline to process data before sending out to this output"""
-    system_fields: NotRequired[List[str]]
-    r"""Fields to automatically add to events, such as cribl_pipe. Supports wildcards."""
-    environment: NotRequired[str]
-    r"""Optionally, enable this config only on a specified Git branch. If empty, will be enabled everywhere."""
-    streamtags: NotRequired[List[str]]
-    r"""Tags for filtering and grouping in @{product}"""
-    dest_path: NotRequired[str]
-    r"""Optional path to prepend to files before uploading. Must be a JavaScript expression (which can evaluate to a constant value), enclosed in quotes or backticks. Can be evaluated only at init time. Example referencing a Global Variable: `myEventsVolumePath-${C.vars.myVar}`"""
-    stage_path: NotRequired[str]
-    r"""Filesystem location in which to buffer files before compressing and moving to final destination. Use performant, stable storage."""
-    add_id_to_stage_path: NotRequired[bool]
-    r"""Add the Output ID value to staging location"""
-    remove_empty_dirs: NotRequired[bool]
-    r"""Remove empty staging directories after moving files"""
-    partition_expr: NotRequired[str]
-    r"""JavaScript expression defining how files are partitioned and organized. Default is date-based. If blank, Stream will fall back to the event's __partition field value – if present – otherwise to each location's root directory."""
-    format_: NotRequired[OutputDatabricksDataFormat]
-    r"""Format of the output data"""
-    base_file_name: NotRequired[str]
-    r"""JavaScript expression to define the output filename prefix (can be constant)"""
-    file_name_suffix: NotRequired[str]
-    r"""JavaScript expression to define the output filename suffix (can be constant).  The `__format` variable refers to the value of the `Data format` field (`json` or `raw`).  The `__compression` field refers to the kind of compression being used (`none` or `gzip`)."""
-    max_file_size_mb: NotRequired[float]
-    r"""Maximum uncompressed output file size. Files of this size will be closed and moved to final output location."""
-    max_file_open_time_sec: NotRequired[float]
-    r"""Maximum amount of time to write to a file. Files open for longer than this will be closed and moved to final output location."""
-    max_file_idle_time_sec: NotRequired[float]
-    r"""Maximum amount of time to keep inactive files open. Files open for longer than this will be closed and moved to final output location."""
-    max_open_files: NotRequired[float]
-    r"""Maximum number of files to keep open concurrently. When exceeded, @{product} will close the oldest open files and move them to the final output location."""
-    header_line: NotRequired[str]
-    r"""If set, this line will be written to the beginning of each output file"""
-    write_high_water_mark: NotRequired[float]
-    r"""Buffer size used to write to a file"""
-    on_backpressure: NotRequired[OutputDatabricksBackpressureBehavior]
-    r"""How to handle events when all receivers are exerting backpressure"""
-    deadletter_enabled: NotRequired[bool]
-    r"""If a file fails to move to its final destination after the maximum number of retries, move it to a designated directory to prevent further errors"""
-    on_disk_full_backpressure: NotRequired[OutputDatabricksDiskSpaceProtection]
-    r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
-    scope: NotRequired[str]
-    r"""OAuth scope for Unity Catalog authentication"""
-    catalog: NotRequired[str]
-    r"""Name of the catalog to use for the output"""
-    schema_: NotRequired[str]
-    r"""Name of the catalog schema to use for the output"""
-    events_volume_name: NotRequired[str]
-    r"""Name of the events volume in Databricks"""
-    description: NotRequired[str]
-    compress: NotRequired[OutputDatabricksCompression]
-    r"""Data compression format to apply to HTTP content before it is delivered"""
-    compression_level: NotRequired[OutputDatabricksCompressionLevel]
-    r"""Compression level to apply before moving files to final destination"""
-    automatic_schema: NotRequired[bool]
-    r"""Automatically calculate the schema based on the events of each Parquet file generated"""
-    parquet_schema: NotRequired[str]
-    r"""To add a new schema, navigate to Processing > Knowledge > Parquet Schemas"""
-    parquet_version: NotRequired[OutputDatabricksParquetVersion]
-    r"""Determines which data types are supported and how they are represented"""
-    parquet_data_page_version: NotRequired[OutputDatabricksDataPageVersion]
-    r"""Serialization format of data pages. Note that some reader implementations use Data page V2's attributes to work more efficiently, while others ignore it."""
-    parquet_row_group_length: NotRequired[float]
-    r"""The number of rows that every group will contain. The final group can contain a smaller number of rows."""
-    parquet_page_size: NotRequired[str]
-    r"""Target memory size for page segments, such as 1MB or 128MB. Generally, lower values improve reading speed, while higher values improve compression."""
-    should_log_invalid_rows: NotRequired[bool]
-    r"""Log up to 3 rows that @{product} skips due to data mismatch"""
-    key_value_metadata: NotRequired[List[OutputDatabricksKeyValueMetadatumTypedDict]]
-    r"""The metadata of files the Destination writes will include the properties you add here as key-value pairs. Useful for tagging. Examples: \"key\":\"OCSF Event Class\", \"value\":\"9001\" """
-    enable_statistics: NotRequired[bool]
-    r"""Statistics profile an entire file in terms of minimum/maximum values within data, numbers of nulls, etc. You can use Parquet tools to view statistics."""
-    enable_write_page_index: NotRequired[bool]
-    r"""One page index contains statistics for one data page. Parquet readers use statistics to enable page skipping."""
-    enable_page_checksum: NotRequired[bool]
-    r"""Parquet tools can use the checksum of a Parquet page to verify data integrity"""
-    empty_dir_cleanup_sec: NotRequired[float]
-    r"""How frequently, in seconds, to clean up empty directories"""
-    deadletter_path: NotRequired[str]
-    r"""Storage location for files that fail to reach their final destination after maximum retries are exceeded"""
-    max_retry_num: NotRequired[float]
-    r"""The maximum number of times a file will attempt to move to its final destination before being dead-lettered"""
-
-
-class OutputDatabricks(BaseModel):
-    type: OutputDatabricksType
-
-    workspace_id: Annotated[str, pydantic.Field(alias="workspaceId")]
-    r"""Databricks workspace ID"""
-
-    client_id: Annotated[str, pydantic.Field(alias="clientId")]
-    r"""OAuth client ID for Unity Catalog authentication"""
-
-    client_secret: Annotated[str, pydantic.Field(alias="clientSecret")]
-    r"""OAuth client secret for Unity Catalog authentication"""
-
-    id: Optional[str] = None
-    r"""Unique ID for this output"""
-
-    pipeline: Optional[str] = None
-    r"""Pipeline to process data before sending out to this output"""
-
-    system_fields: Annotated[
-        Optional[List[str]], pydantic.Field(alias="systemFields")
-    ] = None
-    r"""Fields to automatically add to events, such as cribl_pipe. Supports wildcards."""
-
-    environment: Optional[str] = None
-    r"""Optionally, enable this config only on a specified Git branch. If empty, will be enabled everywhere."""
-
-    streamtags: Optional[List[str]] = None
-    r"""Tags for filtering and grouping in @{product}"""
-
-    dest_path: Annotated[Optional[str], pydantic.Field(alias="destPath")] = ""
-    r"""Optional path to prepend to files before uploading. Must be a JavaScript expression (which can evaluate to a constant value), enclosed in quotes or backticks. Can be evaluated only at init time. Example referencing a Global Variable: `myEventsVolumePath-${C.vars.myVar}`"""
-
-    stage_path: Annotated[Optional[str], pydantic.Field(alias="stagePath")] = (
-        "$CRIBL_HOME/state/outputs/staging"
-    )
-    r"""Filesystem location in which to buffer files before compressing and moving to final destination. Use performant, stable storage."""
-
-    add_id_to_stage_path: Annotated[
-        Optional[bool], pydantic.Field(alias="addIdToStagePath")
-    ] = True
-    r"""Add the Output ID value to staging location"""
-
-    remove_empty_dirs: Annotated[
-        Optional[bool], pydantic.Field(alias="removeEmptyDirs")
-    ] = True
-    r"""Remove empty staging directories after moving files"""
-
-    partition_expr: Annotated[Optional[str], pydantic.Field(alias="partitionExpr")] = (
-        "C.Time.strftime(_time ? _time : Date.now()/1000, '%Y/%m/%d')"
-    )
-    r"""JavaScript expression defining how files are partitioned and organized. Default is date-based. If blank, Stream will fall back to the event's __partition field value – if present – otherwise to each location's root directory."""
-
-    format_: Annotated[
-        Annotated[
-            Optional[OutputDatabricksDataFormat],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="format"),
-    ] = OutputDatabricksDataFormat.JSON
-    r"""Format of the output data"""
-
-    base_file_name: Annotated[Optional[str], pydantic.Field(alias="baseFileName")] = (
-        "`CriblOut`"
-    )
-    r"""JavaScript expression to define the output filename prefix (can be constant)"""
-
-    file_name_suffix: Annotated[
-        Optional[str], pydantic.Field(alias="fileNameSuffix")
-    ] = '`.${C.env["CRIBL_WORKER_ID"]}.${__format}${__compression === "gzip" ? ".gz" : ""}`'
-    r"""JavaScript expression to define the output filename suffix (can be constant).  The `__format` variable refers to the value of the `Data format` field (`json` or `raw`).  The `__compression` field refers to the kind of compression being used (`none` or `gzip`)."""
-
-    max_file_size_mb: Annotated[
-        Optional[float], pydantic.Field(alias="maxFileSizeMB")
-    ] = 32
-    r"""Maximum uncompressed output file size. Files of this size will be closed and moved to final output location."""
-
-    max_file_open_time_sec: Annotated[
-        Optional[float], pydantic.Field(alias="maxFileOpenTimeSec")
-    ] = 300
-    r"""Maximum amount of time to write to a file. Files open for longer than this will be closed and moved to final output location."""
-
-    max_file_idle_time_sec: Annotated[
-        Optional[float], pydantic.Field(alias="maxFileIdleTimeSec")
-    ] = 30
-    r"""Maximum amount of time to keep inactive files open. Files open for longer than this will be closed and moved to final output location."""
-
-    max_open_files: Annotated[Optional[float], pydantic.Field(alias="maxOpenFiles")] = (
-        100
-    )
-    r"""Maximum number of files to keep open concurrently. When exceeded, @{product} will close the oldest open files and move them to the final output location."""
-
-    header_line: Annotated[Optional[str], pydantic.Field(alias="headerLine")] = ""
-    r"""If set, this line will be written to the beginning of each output file"""
-
-    write_high_water_mark: Annotated[
-        Optional[float], pydantic.Field(alias="writeHighWaterMark")
-    ] = 64
-    r"""Buffer size used to write to a file"""
-
-    on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputDatabricksBackpressureBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="onBackpressure"),
-    ] = OutputDatabricksBackpressureBehavior.BLOCK
-    r"""How to handle events when all receivers are exerting backpressure"""
-
-    deadletter_enabled: Annotated[
-        Optional[bool], pydantic.Field(alias="deadletterEnabled")
-    ] = False
-    r"""If a file fails to move to its final destination after the maximum number of retries, move it to a designated directory to prevent further errors"""
-
-    on_disk_full_backpressure: Annotated[
-        Annotated[
-            Optional[OutputDatabricksDiskSpaceProtection],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="onDiskFullBackpressure"),
-    ] = OutputDatabricksDiskSpaceProtection.BLOCK
-    r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
-
-    scope: Optional[str] = "all-apis"
-    r"""OAuth scope for Unity Catalog authentication"""
-
-    catalog: Optional[str] = "main"
-    r"""Name of the catalog to use for the output"""
-
-    schema_: Annotated[Optional[str], pydantic.Field(alias="schema")] = "external"
-    r"""Name of the catalog schema to use for the output"""
-
-    events_volume_name: Annotated[
-        Optional[str], pydantic.Field(alias="eventsVolumeName")
-    ] = "events"
-    r"""Name of the events volume in Databricks"""
-
-    description: Optional[str] = None
-
-    compress: Annotated[
-        Optional[OutputDatabricksCompression], PlainValidator(validate_open_enum(False))
-    ] = OutputDatabricksCompression.GZIP
-    r"""Data compression format to apply to HTTP content before it is delivered"""
-
-    compression_level: Annotated[
-        Annotated[
-            Optional[OutputDatabricksCompressionLevel],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="compressionLevel"),
-    ] = OutputDatabricksCompressionLevel.BEST_SPEED
-    r"""Compression level to apply before moving files to final destination"""
-
-    automatic_schema: Annotated[
-        Optional[bool], pydantic.Field(alias="automaticSchema")
-    ] = False
-    r"""Automatically calculate the schema based on the events of each Parquet file generated"""
-
-    parquet_schema: Annotated[Optional[str], pydantic.Field(alias="parquetSchema")] = (
-        None
-    )
-    r"""To add a new schema, navigate to Processing > Knowledge > Parquet Schemas"""
-
-    parquet_version: Annotated[
-        Annotated[
-            Optional[OutputDatabricksParquetVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="parquetVersion"),
-    ] = OutputDatabricksParquetVersion.PARQUET_2_6
-    r"""Determines which data types are supported and how they are represented"""
-
-    parquet_data_page_version: Annotated[
-        Annotated[
-            Optional[OutputDatabricksDataPageVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="parquetDataPageVersion"),
-    ] = OutputDatabricksDataPageVersion.DATA_PAGE_V2
-    r"""Serialization format of data pages. Note that some reader implementations use Data page V2's attributes to work more efficiently, while others ignore it."""
-
-    parquet_row_group_length: Annotated[
-        Optional[float], pydantic.Field(alias="parquetRowGroupLength")
-    ] = 10000
-    r"""The number of rows that every group will contain. The final group can contain a smaller number of rows."""
-
-    parquet_page_size: Annotated[
-        Optional[str], pydantic.Field(alias="parquetPageSize")
-    ] = "1MB"
-    r"""Target memory size for page segments, such as 1MB or 128MB. Generally, lower values improve reading speed, while higher values improve compression."""
-
-    should_log_invalid_rows: Annotated[
-        Optional[bool], pydantic.Field(alias="shouldLogInvalidRows")
-    ] = None
-    r"""Log up to 3 rows that @{product} skips due to data mismatch"""
-
-    key_value_metadata: Annotated[
-        Optional[List[OutputDatabricksKeyValueMetadatum]],
-        pydantic.Field(alias="keyValueMetadata"),
-    ] = None
-    r"""The metadata of files the Destination writes will include the properties you add here as key-value pairs. Useful for tagging. Examples: \"key\":\"OCSF Event Class\", \"value\":\"9001\" """
-
-    enable_statistics: Annotated[
-        Optional[bool], pydantic.Field(alias="enableStatistics")
-    ] = True
-    r"""Statistics profile an entire file in terms of minimum/maximum values within data, numbers of nulls, etc. You can use Parquet tools to view statistics."""
-
-    enable_write_page_index: Annotated[
-        Optional[bool], pydantic.Field(alias="enableWritePageIndex")
-    ] = True
-    r"""One page index contains statistics for one data page. Parquet readers use statistics to enable page skipping."""
-
-    enable_page_checksum: Annotated[
-        Optional[bool], pydantic.Field(alias="enablePageChecksum")
-    ] = False
-    r"""Parquet tools can use the checksum of a Parquet page to verify data integrity"""
-
-    empty_dir_cleanup_sec: Annotated[
-        Optional[float], pydantic.Field(alias="emptyDirCleanupSec")
-    ] = 300
-    r"""How frequently, in seconds, to clean up empty directories"""
-
-    deadletter_path: Annotated[
-        Optional[str], pydantic.Field(alias="deadletterPath")
-    ] = "$CRIBL_HOME/state/outputs/dead-letter"
-    r"""Storage location for files that fail to reach their final destination after maximum retries are exceeded"""
-
-    max_retry_num: Annotated[Optional[float], pydantic.Field(alias="maxRetryNum")] = 20
-    r"""The maximum number of times a file will attempt to move to its final destination before being dead-lettered"""
-
-    @field_serializer("format_")
-    def serialize_format_(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDatabricksDataFormat(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("on_backpressure")
-    def serialize_on_backpressure(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDatabricksBackpressureBehavior(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("on_disk_full_backpressure")
-    def serialize_on_disk_full_backpressure(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDatabricksDiskSpaceProtection(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("compress")
-    def serialize_compress(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDatabricksCompression(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("compression_level")
-    def serialize_compression_level(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDatabricksCompressionLevel(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("parquet_version")
-    def serialize_parquet_version(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDatabricksParquetVersion(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("parquet_data_page_version")
-    def serialize_parquet_data_page_version(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDatabricksDataPageVersion(value)
-            except ValueError:
-                return value
-        return value