cribl-control-plane 0.0.38__py3-none-any.whl → 0.4.0a6__py3-none-any.whl

cribl_control_plane/models/inputexec.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 InputExecConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputExecMode(str, Enum):
+class InputExecMode(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 InputExecCompression(str, Enum):
+class InputExecCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
+    # None
     NONE = "none"
+    # Gzip
     GZIP = "gzip"
 
 
+class InputExecPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputExecPqControls(BaseModel):
+    pass
+
+
 class InputExecPqTypedDict(TypedDict):
     mode: NotRequired[InputExecMode]
     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 InputExecPqTypedDict(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[InputExecCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputExecPqControlsTypedDict]
 
 
 class InputExecPq(BaseModel):
-    mode: Optional[InputExecMode] = InputExecMode.ALWAYS
+    mode: Annotated[
+        Optional[InputExecMode], PlainValidator(validate_open_enum(False))
+    ] = InputExecMode.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,11 +98,35 @@ class InputExecPq(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[InputExecCompression] = InputExecCompression.NONE
+    compress: Annotated[
+        Optional[InputExecCompression], PlainValidator(validate_open_enum(False))
+    ] = InputExecCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputExecPqControls], pydantic.Field(alias="pqControls")
+    ] = None
 
-class ScheduleType(str, Enum):
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputExecMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputExecCompression(value)
+            except ValueError:
+                return value
+        return value
+
+
+class ScheduleType(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Select a schedule type; either an interval (in seconds) or a cron-style schedule."""
 
     INTERVAL = "interval"
@@ -177,7 +220,8 @@ class InputExec(BaseModel):
     r"""Maximum number of retry attempts in the event that the command fails"""
 
     schedule_type: Annotated[
-        Optional[ScheduleType], pydantic.Field(alias="scheduleType")
+        Annotated[Optional[ScheduleType], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="scheduleType"),
     ] = ScheduleType.INTERVAL
     r"""Select a schedule type; either an interval (in seconds) or a cron-style schedule."""
 
@@ -203,3 +247,12 @@ class InputExec(BaseModel):
         "* * * * *"
     )
     r"""Cron schedule to execute the command on."""
+
+    @field_serializer("schedule_type")
+    def serialize_schedule_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.ScheduleType(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/inputfile.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 InputFileConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputFilePqMode(str, Enum):
+class InputFilePqMode(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 InputFileCompression(str, Enum):
+class InputFileCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
+    # None
     NONE = "none"
+    # Gzip
     GZIP = "gzip"
 
 
+class InputFilePqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputFilePqControls(BaseModel):
+    pass
+
+
 class InputFilePqTypedDict(TypedDict):
     mode: NotRequired[InputFilePqMode]
     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 InputFilePqTypedDict(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[InputFileCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputFilePqControlsTypedDict]
 
 
 class InputFilePq(BaseModel):
-    mode: Optional[InputFilePqMode] = InputFilePqMode.ALWAYS
+    mode: Annotated[
+        Optional[InputFilePqMode], PlainValidator(validate_open_enum(False))
+    ] = InputFilePqMode.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,15 +98,41 @@ class InputFilePq(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[InputFileCompression] = InputFileCompression.NONE
+    compress: Annotated[
+        Optional[InputFileCompression], PlainValidator(validate_open_enum(False))
+    ] = InputFileCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputFilePqControls], pydantic.Field(alias="pqControls")
+    ] = None
 
-class InputFileMode(str, Enum):
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputFilePqMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputFileCompression(value)
+            except ValueError:
+                return value
+        return value
+
+
+class InputFileMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Choose how to discover files to monitor"""
 
-    AUTO = "auto"
+    # Manual
     MANUAL = "manual"
+    # Auto
+    AUTO = "auto"
 
 
 class InputFileMetadatumTypedDict(TypedDict):
@@ -127,12 +172,16 @@ class InputFileTypedDict(TypedDict):
     r"""Time, in seconds, between scanning for files"""
     filenames: NotRequired[List[str]]
     r"""The full path of discovered files are matched against this wildcard list"""
+    filter_archived_files: NotRequired[bool]
+    r"""Apply filename allowlist to file entries in archive file types, like tar or zip."""
     tail_only: NotRequired[bool]
     r"""Read only new entries at the end of all files discovered at next startup. @{product} will then read newly discovered files from the head. Disable this to resume reading all files from head."""
     idle_timeout: NotRequired[float]
     r"""Time, in seconds, before an idle file is closed"""
+    min_age_dur: NotRequired[str]
+    r"""The minimum age of files to monitor. Format examples: 30s, 15m, 1h. Age is relative to file modification time. Leave empty to apply no age filters."""
     max_age_dur: NotRequired[str]
-    r"""The maximum age of files to monitor. Format examples: 60s, 4h, 3d, 1w. Age is relative to file modification time. Leave empty to apply no age filters."""
+    r"""The maximum age of event timestamps to collect. Format examples: 60s, 4h, 3d, 1w. Can be used in conjuction with \"Check file modification times\". Leave empty to apply no age filters."""
     check_file_mod_time: NotRequired[bool]
     r"""Skip files with modification times earlier than the maximum age duration"""
     force_text: NotRequired[bool]
@@ -187,7 +236,9 @@ class InputFile(BaseModel):
 
     pq: Optional[InputFilePq] = None
 
-    mode: Optional[InputFileMode] = InputFileMode.AUTO
+    mode: Annotated[
+        Optional[InputFileMode], PlainValidator(validate_open_enum(False))
+    ] = InputFileMode.MANUAL
     r"""Choose how to discover files to monitor"""
 
     interval: Optional[float] = 10
@@ -196,14 +247,22 @@ class InputFile(BaseModel):
     filenames: Optional[List[str]] = None
     r"""The full path of discovered files are matched against this wildcard list"""
 
-    tail_only: Annotated[Optional[bool], pydantic.Field(alias="tailOnly")] = False
+    filter_archived_files: Annotated[
+        Optional[bool], pydantic.Field(alias="filterArchivedFiles")
+    ] = False
+    r"""Apply filename allowlist to file entries in archive file types, like tar or zip."""
+
+    tail_only: Annotated[Optional[bool], pydantic.Field(alias="tailOnly")] = True
     r"""Read only new entries at the end of all files discovered at next startup. @{product} will then read newly discovered files from the head. Disable this to resume reading all files from head."""
 
     idle_timeout: Annotated[Optional[float], pydantic.Field(alias="idleTimeout")] = 300
     r"""Time, in seconds, before an idle file is closed"""
 
+    min_age_dur: Annotated[Optional[str], pydantic.Field(alias="minAgeDur")] = None
+    r"""The minimum age of files to monitor. Format examples: 30s, 15m, 1h. Age is relative to file modification time. Leave empty to apply no age filters."""
+
     max_age_dur: Annotated[Optional[str], pydantic.Field(alias="maxAgeDur")] = None
-    r"""The maximum age of files to monitor. Format examples: 60s, 4h, 3d, 1w. Age is relative to file modification time. Leave empty to apply no age filters."""
+    r"""The maximum age of event timestamps to collect. Format examples: 60s, 4h, 3d, 1w. Can be used in conjuction with \"Check file modification times\". Leave empty to apply no age filters."""
 
     check_file_mod_time: Annotated[
         Optional[bool], pydantic.Field(alias="checkFileModTime")
@@ -248,3 +307,12 @@ class InputFile(BaseModel):
         Optional[bool], pydantic.Field(alias="includeUnidentifiableBinary")
     ] = False
     r"""Stream binary files as Base64-encoded chunks."""
+
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputFileMode(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/inputfirehose.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 InputFirehoseConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputFirehoseMode(str, Enum):
+class InputFirehoseMode(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 InputFirehoseCompression(str, Enum):
+class InputFirehoseCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
+    # None
     NONE = "none"
+    # Gzip
     GZIP = "gzip"
 
 
+class InputFirehosePqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputFirehosePqControls(BaseModel):
+    pass
+
+
 class InputFirehosePqTypedDict(TypedDict):
     mode: NotRequired[InputFirehoseMode]
     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 InputFirehosePqTypedDict(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[InputFirehoseCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputFirehosePqControlsTypedDict]
 
 
 class InputFirehosePq(BaseModel):
-    mode: Optional[InputFirehoseMode] = InputFirehoseMode.ALWAYS
+    mode: Annotated[
+        Optional[InputFirehoseMode], PlainValidator(validate_open_enum(False))
+    ] = InputFirehoseMode.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 InputFirehosePq(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[InputFirehoseCompression] = InputFirehoseCompression.NONE
+    compress: Annotated[
+        Optional[InputFirehoseCompression], PlainValidator(validate_open_enum(False))
+    ] = InputFirehoseCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputFirehosePqControls], pydantic.Field(alias="pqControls")
+    ] = None
 
-class InputFirehoseMinimumTLSVersion(str, Enum):
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputFirehoseMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputFirehoseCompression(value)
+            except ValueError:
+                return value
+        return value
+
+
+class InputFirehoseMinimumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
     TL_SV1_3 = "TLSv1.3"
 
 
-class InputFirehoseMaximumTLSVersion(str, Enum):
+class InputFirehoseMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
@@ -99,6 +142,12 @@ class InputFirehoseMaximumTLSVersion(str, Enum):
 
 class InputFirehoseTLSSettingsServerSideTypedDict(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 InputFirehoseTLSSettingsServerSideTypedDict(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[InputFirehoseMinimumTLSVersion]
     max_version: NotRequired[InputFirehoseMaximumTLSVersion]
 
@@ -120,6 +165,19 @@ class InputFirehoseTLSSettingsServerSideTypedDict(TypedDict):
 class InputFirehoseTLSSettingsServerSide(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 InputFirehoseTLSSettingsServerSide(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[InputFirehoseMinimumTLSVersion], pydantic.Field(alias="minVersion")
+        Annotated[
+            Optional[InputFirehoseMinimumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="minVersion"),
     ] = None
 
     max_version: Annotated[
-        Optional[InputFirehoseMaximumTLSVersion], pydantic.Field(alias="maxVersion")
+        Annotated[
+            Optional[InputFirehoseMaximumTLSVersion],
+            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.InputFirehoseMinimumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("max_version")
+    def serialize_max_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputFirehoseMaximumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputFirehoseMetadatumTypedDict(TypedDict):
     name: str

cribl_control_plane/models/inputgooglepubsub.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 InputGooglePubsubConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputGooglePubsubMode(str, Enum):
+class InputGooglePubsubMode(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 InputGooglePubsubCompression(str, Enum):
+class InputGooglePubsubCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
+    # None
     NONE = "none"
+    # Gzip
     GZIP = "gzip"
 
 
+class InputGooglePubsubPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputGooglePubsubPqControls(BaseModel):
+    pass
+
+
 class InputGooglePubsubPqTypedDict(TypedDict):
     mode: NotRequired[InputGooglePubsubMode]
     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 InputGooglePubsubPqTypedDict(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[InputGooglePubsubCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputGooglePubsubPqControlsTypedDict]
 
 
 class InputGooglePubsubPq(BaseModel):
-    mode: Optional[InputGooglePubsubMode] = InputGooglePubsubMode.ALWAYS
+    mode: Annotated[
+        Optional[InputGooglePubsubMode], PlainValidator(validate_open_enum(False))
+    ] = InputGooglePubsubMode.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,15 +98,45 @@ class InputGooglePubsubPq(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[InputGooglePubsubCompression] = InputGooglePubsubCompression.NONE
+    compress: Annotated[
+        Optional[InputGooglePubsubCompression],
+        PlainValidator(validate_open_enum(False)),
+    ] = InputGooglePubsubCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputGooglePubsubPqControls], pydantic.Field(alias="pqControls")
+    ] = None
 
-class InputGooglePubsubGoogleAuthenticationMethod(str, Enum):
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputGooglePubsubMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputGooglePubsubCompression(value)
+            except ValueError:
+                return value
+        return value
+
+
+class InputGooglePubsubGoogleAuthenticationMethod(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
     r"""Choose Auto to use Google Application Default Credentials (ADC), Manual to enter Google service account credentials directly, or Secret to select or create a stored secret that references Google service account credentials."""
 
+    # Auto
     AUTO = "auto"
+    # Manual
     MANUAL = "manual"
+    # Secret
     SECRET = "secret"
 
 
@@ -206,7 +255,10 @@ class InputGooglePubsub(BaseModel):
     r"""Region to retrieve messages from. Select 'default' to allow Google to auto-select the nearest region. When using ordered delivery, the selected region must be allowed by message storage policy."""
 
     google_auth_method: Annotated[
-        Optional[InputGooglePubsubGoogleAuthenticationMethod],
+        Annotated[
+            Optional[InputGooglePubsubGoogleAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="googleAuthMethod"),
     ] = InputGooglePubsubGoogleAuthenticationMethod.MANUAL
     r"""Choose Auto to use Google Application Default Credentials (ADC), Manual to enter Google service account credentials directly, or Secret to select or create a stored secret that references Google service account credentials."""
@@ -239,3 +291,12 @@ class InputGooglePubsub(BaseModel):
         Optional[bool], pydantic.Field(alias="orderedDelivery")
     ] = False
     r"""Receive events in the order they were added to the queue. The process sending events must have ordering enabled."""
+
+    @field_serializer("google_auth_method")
+    def serialize_google_auth_method(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputGooglePubsubGoogleAuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value