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

cribl_control_plane/models/inputwineventlogs.py

@@ -1,9 +1,13 @@
 """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
 
@@ -23,20 +27,32 @@ class InputWinEventLogsConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputWinEventLogsMode(str, Enum):
+class InputWinEventLogsMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
+    # Smart
     SMART = "smart"
+    # Always On
     ALWAYS = "always"
 
 
-class InputWinEventLogsCompression(str, Enum):
+class InputWinEventLogsCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
+    # None
     NONE = "none"
+    # Gzip
     GZIP = "gzip"
 
 
+class InputWinEventLogsPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputWinEventLogsPqControls(BaseModel):
+    pass
+
+
 class InputWinEventLogsPqTypedDict(TypedDict):
     mode: NotRequired[InputWinEventLogsMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,10 +68,13 @@ class InputWinEventLogsPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputWinEventLogsCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputWinEventLogsPqControlsTypedDict]
 
 
 class InputWinEventLogsPq(BaseModel):
-    mode: Optional[InputWinEventLogsMode] = InputWinEventLogsMode.ALWAYS
+    mode: Annotated[
+        Optional[InputWinEventLogsMode], PlainValidator(validate_open_enum(False))
+    ] = InputWinEventLogsMode.ALWAYS
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
     max_buffer_size: Annotated[
@@ -79,21 +98,50 @@ class InputWinEventLogsPq(BaseModel):
     path: Optional[str] = "$CRIBL_HOME/state/queues"
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
 
-    compress: Optional[InputWinEventLogsCompression] = InputWinEventLogsCompression.NONE
+    compress: Annotated[
+        Optional[InputWinEventLogsCompression],
+        PlainValidator(validate_open_enum(False)),
+    ] = InputWinEventLogsCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
-
-class ReadMode(str, Enum):
+    pq_controls: Annotated[
+        Optional[InputWinEventLogsPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputWinEventLogsMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputWinEventLogsCompression(value)
+            except ValueError:
+                return value
+        return value
+
+
+class ReadMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Read all stored and future event logs, or only future events"""
 
+    # Entire log
     OLDEST = "oldest"
+    # From last entry
     NEWEST = "newest"
 
 
-class EventFormat(str, Enum):
+class EventFormat(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Format of individual events"""
 
+    # JSON
     JSON = "json"
+    # XML
     XML = "xml"
 
 
@@ -145,6 +193,10 @@ class InputWinEventLogsTypedDict(TypedDict):
     max_event_bytes: NotRequired[float]
     r"""The maximum number of bytes in an event before it is flushed to the pipelines"""
     description: NotRequired[str]
+    disable_json_rendering: NotRequired[bool]
+    r"""Enable/disable the rendering of localized event message strings (Applicable for 4.8.0 nodes and newer that use the Native API)"""
+    disable_xml_rendering: NotRequired[bool]
+    r"""Enable/disable the rendering of localized event message strings (Applicable for 4.8.0 nodes and newer that use the Native API)"""
 
 
 class InputWinEventLogs(BaseModel):
@@ -180,13 +232,15 @@ class InputWinEventLogs(BaseModel):
 
     pq: Optional[InputWinEventLogsPq] = None
 
-    read_mode: Annotated[Optional[ReadMode], pydantic.Field(alias="readMode")] = (
-        ReadMode.OLDEST
-    )
+    read_mode: Annotated[
+        Annotated[Optional[ReadMode], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="readMode"),
+    ] = ReadMode.NEWEST
     r"""Read all stored and future event logs, or only future events"""
 
     event_format: Annotated[
-        Optional[EventFormat], pydantic.Field(alias="eventFormat")
+        Annotated[Optional[EventFormat], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="eventFormat"),
     ] = EventFormat.JSON
     r"""Format of individual events"""
 
@@ -210,3 +264,31 @@ class InputWinEventLogs(BaseModel):
     r"""The maximum number of bytes in an event before it is flushed to the pipelines"""
 
     description: Optional[str] = None
+
+    disable_json_rendering: Annotated[
+        Optional[bool], pydantic.Field(alias="disableJsonRendering")
+    ] = False
+    r"""Enable/disable the rendering of localized event message strings (Applicable for 4.8.0 nodes and newer that use the Native API)"""
+
+    disable_xml_rendering: Annotated[
+        Optional[bool], pydantic.Field(alias="disableXmlRendering")
+    ] = True
+    r"""Enable/disable the rendering of localized event message strings (Applicable for 4.8.0 nodes and newer that use the Native API)"""
+
+    @field_serializer("read_mode")
+    def serialize_read_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.ReadMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("event_format")
+    def serialize_event_format(self, value):
+        if isinstance(value, str):
+            try:
+                return models.EventFormat(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/inputwiz.py

@@ -1,9 +1,13 @@
 """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
 
@@ -23,20 +27,32 @@ class InputWizConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputWizMode(str, Enum):
+class InputWizMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
+    # Smart
     SMART = "smart"
+    # Always On
     ALWAYS = "always"
 
 
-class InputWizCompression(str, Enum):
+class InputWizCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
+    # None
     NONE = "none"
+    # Gzip
     GZIP = "gzip"
 
 
+class InputWizPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputWizPqControls(BaseModel):
+    pass
+
+
 class InputWizPqTypedDict(TypedDict):
     mode: NotRequired[InputWizMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,10 +68,13 @@ class InputWizPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputWizCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputWizPqControlsTypedDict]
 
 
 class InputWizPq(BaseModel):
-    mode: Optional[InputWizMode] = InputWizMode.ALWAYS
+    mode: Annotated[
+        Optional[InputWizMode], PlainValidator(validate_open_enum(False))
+    ] = InputWizMode.ALWAYS
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
     max_buffer_size: Annotated[
@@ -79,27 +98,146 @@ class InputWizPq(BaseModel):
     path: Optional[str] = "$CRIBL_HOME/state/queues"
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
 
-    compress: Optional[InputWizCompression] = InputWizCompression.NONE
+    compress: Annotated[
+        Optional[InputWizCompression], PlainValidator(validate_open_enum(False))
+    ] = InputWizCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputWizPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputWizMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputWizCompression(value)
+            except ValueError:
+                return value
+        return value
+
+
+class ManageStateTypedDict(TypedDict):
+    pass
+
+
+class ManageState(BaseModel):
+    pass
+
+
+class InputWizLogLevel(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Collector runtime log level"""
+
+    ERROR = "error"
+    WARN = "warn"
+    INFO = "info"
+    DEBUG = "debug"
+    SILLY = "silly"
+
 
 class InputWizContentConfigTypedDict(TypedDict):
     content_type: str
     r"""The name of the Wiz query"""
+    content_query: str
+    r"""Template for POST body to send with the Collect request. Reference global variables, or functions using template params: `${C.vars.myVar}`, or `${Date.now()}`, `${param}`."""
     content_description: NotRequired[str]
     enabled: NotRequired[bool]
+    state_tracking: NotRequired[bool]
+    r"""Track collection progress between consecutive scheduled executions"""
+    state_update_expression: NotRequired[str]
+    r"""JavaScript expression that defines how to update the state from an event. Use the event's data and the current state to compute the new state. See [Understanding State Expression Fields](https://docs.cribl.io/stream/collectors-rest#state-tracking-expression-fields) for more information."""
+    state_merge_expression: NotRequired[str]
+    r"""JavaScript expression that defines which state to keep when merging a task's newly reported state with previously saved state. Evaluates `prevState` and `newState` variables, resolving to the state to keep."""
+    manage_state: NotRequired[ManageStateTypedDict]
+    cron_schedule: NotRequired[str]
+    r"""A cron schedule on which to run this job"""
+    earliest: NotRequired[str]
+    r"""Earliest time, relative to now. Format supported: [+|-]<time_integer><time_unit>@<snap-to_time_unit> (ex: -1hr, -42m, -42m@h)"""
+    latest: NotRequired[str]
+    r"""Latest time, relative to now. Format supported: [+|-]<time_integer><time_unit>@<snap-to_time_unit> (ex: -1hr, -42m, -42m@h)"""
+    job_timeout: NotRequired[str]
+    r"""Maximum time the job is allowed to run (examples: 30, 45s, 15m). Units default to seconds if not specified. Enter 0 for unlimited time."""
+    log_level: NotRequired[InputWizLogLevel]
+    r"""Collector runtime log level"""
+    max_pages: NotRequired[float]
+    r"""Maximum number of pages to retrieve per collection task. Defaults to 0. Set to 0 to retrieve all pages."""
 
 
 class InputWizContentConfig(BaseModel):
     content_type: Annotated[str, pydantic.Field(alias="contentType")]
     r"""The name of the Wiz query"""
 
+    content_query: Annotated[str, pydantic.Field(alias="contentQuery")]
+    r"""Template for POST body to send with the Collect request. Reference global variables, or functions using template params: `${C.vars.myVar}`, or `${Date.now()}`, `${param}`."""
+
     content_description: Annotated[
         Optional[str], pydantic.Field(alias="contentDescription")
     ] = None
 
     enabled: Optional[bool] = False
 
+    state_tracking: Annotated[Optional[bool], pydantic.Field(alias="stateTracking")] = (
+        False
+    )
+    r"""Track collection progress between consecutive scheduled executions"""
+
+    state_update_expression: Annotated[
+        Optional[str], pydantic.Field(alias="stateUpdateExpression")
+    ] = "__timestampExtracted !== false && {latestTime: (state.latestTime || 0) > _time ? state.latestTime : _time}"
+    r"""JavaScript expression that defines how to update the state from an event. Use the event's data and the current state to compute the new state. See [Understanding State Expression Fields](https://docs.cribl.io/stream/collectors-rest#state-tracking-expression-fields) for more information."""
+
+    state_merge_expression: Annotated[
+        Optional[str], pydantic.Field(alias="stateMergeExpression")
+    ] = "prevState.latestTime > newState.latestTime ? prevState : newState"
+    r"""JavaScript expression that defines which state to keep when merging a task's newly reported state with previously saved state. Evaluates `prevState` and `newState` variables, resolving to the state to keep."""
+
+    manage_state: Annotated[
+        Optional[ManageState], pydantic.Field(alias="manageState")
+    ] = None
+
+    cron_schedule: Annotated[Optional[str], pydantic.Field(alias="cronSchedule")] = (
+        "0 */12 * * *"
+    )
+    r"""A cron schedule on which to run this job"""
+
+    earliest: Optional[str] = "-12h@h"
+    r"""Earliest time, relative to now. Format supported: [+|-]<time_integer><time_unit>@<snap-to_time_unit> (ex: -1hr, -42m, -42m@h)"""
+
+    latest: Optional[str] = "now"
+    r"""Latest time, relative to now. Format supported: [+|-]<time_integer><time_unit>@<snap-to_time_unit> (ex: -1hr, -42m, -42m@h)"""
+
+    job_timeout: Annotated[Optional[str], pydantic.Field(alias="jobTimeout")] = "0"
+    r"""Maximum time the job is allowed to run (examples: 30, 45s, 15m). Units default to seconds if not specified. Enter 0 for unlimited time."""
+
+    log_level: Annotated[
+        Annotated[
+            Optional[InputWizLogLevel], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="logLevel"),
+    ] = InputWizLogLevel.INFO
+    r"""Collector runtime log level"""
+
+    max_pages: Annotated[Optional[float], pydantic.Field(alias="maxPages")] = 0
+    r"""Maximum number of pages to retrieve per collection task. Defaults to 0. Set to 0 to retrieve all pages."""
+
+    @field_serializer("log_level")
+    def serialize_log_level(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputWizLogLevel(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputWizMetadatumTypedDict(TypedDict):
     name: str
@@ -114,11 +252,14 @@ class InputWizMetadatum(BaseModel):
     r"""JavaScript expression to compute field's value, enclosed in quotes or backticks. (Can evaluate to a constant.)"""
 
 
-class InputWizRetryType(str, Enum):
+class InputWizRetryType(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""The algorithm to use when performing HTTP retries"""
 
+    # Disabled
     NONE = "none"
+    # Backoff
     BACKOFF = "backoff"
+    # Static
     STATIC = "static"
 
 
@@ -142,7 +283,9 @@ class InputWizRetryRulesTypedDict(TypedDict):
 
 
 class InputWizRetryRules(BaseModel):
-    type: Optional[InputWizRetryType] = InputWizRetryType.BACKOFF
+    type: Annotated[
+        Optional[InputWizRetryType], PlainValidator(validate_open_enum(False))
+    ] = InputWizRetryType.BACKOFF
     r"""The algorithm to use when performing HTTP retries"""
 
     interval: Optional[float] = 1000
@@ -172,8 +315,17 @@ class InputWizRetryRules(BaseModel):
     ] = False
     r"""Retry request when a connection reset (ECONNRESET) error occurs"""
 
+    @field_serializer("type")
+    def serialize_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputWizRetryType(value)
+            except ValueError:
+                return value
+        return value
 
-class InputWizAuthenticationMethod(str, Enum):
+
+class InputWizAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Enter client secret directly, or select a stored secret"""
 
     MANUAL = "manual"
@@ -308,7 +460,11 @@ class InputWiz(BaseModel):
     ] = None
 
     auth_type: Annotated[
-        Optional[InputWizAuthenticationMethod], pydantic.Field(alias="authType")
+        Annotated[
+            Optional[InputWizAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
     ] = InputWizAuthenticationMethod.MANUAL
     r"""Enter client secret directly, or select a stored secret"""
 
@@ -319,3 +475,12 @@ class InputWiz(BaseModel):
 
     text_secret: Annotated[Optional[str], pydantic.Field(alias="textSecret")] = None
     r"""Select or create a stored text secret"""
+
+    @field_serializer("auth_type")
+    def serialize_auth_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputWizAuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/inputwizwebhook.py

@@ -1,10 +1,14 @@
 """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 typing import Any, List, Optional
+from pydantic import field_serializer
+from pydantic.functional_validators import PlainValidator
+from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -23,20 +27,32 @@ class InputWizWebhookConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputWizWebhookMode(str, Enum):
+class InputWizWebhookMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
+    # Smart
     SMART = "smart"
+    # Always On
     ALWAYS = "always"
 
 
-class InputWizWebhookCompression(str, Enum):
+class InputWizWebhookCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
+    # None
     NONE = "none"
+    # Gzip
     GZIP = "gzip"
 
 
+class InputWizWebhookPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputWizWebhookPqControls(BaseModel):
+    pass
+
+
 class InputWizWebhookPqTypedDict(TypedDict):
     mode: NotRequired[InputWizWebhookMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,10 +68,13 @@ class InputWizWebhookPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputWizWebhookCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputWizWebhookPqControlsTypedDict]
 
 
 class InputWizWebhookPq(BaseModel):
-    mode: Optional[InputWizWebhookMode] = InputWizWebhookMode.ALWAYS
+    mode: Annotated[
+        Optional[InputWizWebhookMode], PlainValidator(validate_open_enum(False))
+    ] = InputWizWebhookMode.ALWAYS
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
     max_buffer_size: Annotated[
@@ -79,18 +98,42 @@ class InputWizWebhookPq(BaseModel):
     path: Optional[str] = "$CRIBL_HOME/state/queues"
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
 
-    compress: Optional[InputWizWebhookCompression] = InputWizWebhookCompression.NONE
+    compress: Annotated[
+        Optional[InputWizWebhookCompression], PlainValidator(validate_open_enum(False))
+    ] = InputWizWebhookCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputWizWebhookPqControls], pydantic.Field(alias="pqControls")
+    ] = None
 
-class InputWizWebhookMinimumTLSVersion(str, Enum):
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputWizWebhookMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputWizWebhookCompression(value)
+            except ValueError:
+                return value
+        return value
+
+
+class InputWizWebhookMinimumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
     TL_SV1_3 = "TLSv1.3"
 
 
-class InputWizWebhookMaximumTLSVersion(str, Enum):
+class InputWizWebhookMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
@@ -99,6 +142,12 @@ class InputWizWebhookMaximumTLSVersion(str, Enum):
 
 class InputWizWebhookTLSSettingsServerSideTypedDict(TypedDict):
     disabled: NotRequired[bool]
+    request_cert: NotRequired[bool]
+    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
+    reject_unauthorized: NotRequired[bool]
+    r"""Reject certificates not authorized by a CA in the CA certificate path or by another trusted CA (such as the system's)"""
+    common_name_regex: NotRequired[str]
+    r"""Regex matching allowable common names in peer certificates' subject attribute"""
     certificate_name: NotRequired[str]
     r"""The name of the predefined certificate"""
     priv_key_path: NotRequired[str]
@@ -109,10 +158,6 @@ class InputWizWebhookTLSSettingsServerSideTypedDict(TypedDict):
     r"""Path on server containing certificates to use. PEM format. Can reference $ENV_VARS."""
     ca_path: NotRequired[str]
     r"""Path on server containing CA certificates to use. PEM format. Can reference $ENV_VARS."""
-    request_cert: NotRequired[bool]
-    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
-    reject_unauthorized: NotRequired[Any]
-    common_name_regex: NotRequired[Any]
     min_version: NotRequired[InputWizWebhookMinimumTLSVersion]
     max_version: NotRequired[InputWizWebhookMaximumTLSVersion]
 
@@ -120,6 +165,19 @@ class InputWizWebhookTLSSettingsServerSideTypedDict(TypedDict):
 class InputWizWebhookTLSSettingsServerSide(BaseModel):
     disabled: Optional[bool] = True
 
+    request_cert: Annotated[Optional[bool], pydantic.Field(alias="requestCert")] = False
+    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
+
+    reject_unauthorized: Annotated[
+        Optional[bool], pydantic.Field(alias="rejectUnauthorized")
+    ] = True
+    r"""Reject certificates not authorized by a CA in the CA certificate path or by another trusted CA (such as the system's)"""
+
+    common_name_regex: Annotated[
+        Optional[str], pydantic.Field(alias="commonNameRegex")
+    ] = "/.*/"
+    r"""Regex matching allowable common names in peer certificates' subject attribute"""
+
     certificate_name: Annotated[
         Optional[str], pydantic.Field(alias="certificateName")
     ] = None
@@ -137,25 +195,40 @@ class InputWizWebhookTLSSettingsServerSide(BaseModel):
     ca_path: Annotated[Optional[str], pydantic.Field(alias="caPath")] = None
     r"""Path on server containing CA certificates to use. PEM format. Can reference $ENV_VARS."""
 
-    request_cert: Annotated[Optional[bool], pydantic.Field(alias="requestCert")] = False
-    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
-
-    reject_unauthorized: Annotated[
-        Optional[Any], pydantic.Field(alias="rejectUnauthorized")
-    ] = None
-
-    common_name_regex: Annotated[
-        Optional[Any], pydantic.Field(alias="commonNameRegex")
-    ] = None
-
     min_version: Annotated[
-        Optional[InputWizWebhookMinimumTLSVersion], pydantic.Field(alias="minVersion")
+        Annotated[
+            Optional[InputWizWebhookMinimumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="minVersion"),
     ] = None
 
     max_version: Annotated[
-        Optional[InputWizWebhookMaximumTLSVersion], pydantic.Field(alias="maxVersion")
+        Annotated[
+            Optional[InputWizWebhookMaximumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="maxVersion"),
     ] = None
 
+    @field_serializer("min_version")
+    def serialize_min_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputWizWebhookMinimumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("max_version")
+    def serialize_max_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputWizWebhookMaximumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputWizWebhookMetadatumTypedDict(TypedDict):
     name: str