cribl-control-plane 0.2.1rc4__py3-none-any.whl → 0.2.1rc6__py3-none-any.whl

cribl_control_plane/models/outputwavefront.py

@@ -109,17 +109,6 @@ class OutputWavefrontBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMet
     QUEUE = "queue"
 
 
-class OutputWavefrontMode(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
-
-    # Error
-    ERROR = "error"
-    # Backpressure
-    ALWAYS = "always"
-    # Always On
-    BACKPRESSURE = "backpressure"
-
-
 class OutputWavefrontCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
@@ -138,6 +127,17 @@ class OutputWavefrontQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     DROP = "drop"
 
 
+class OutputWavefrontMode(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
+
+    # Error
+    ERROR = "error"
+    # Backpressure
+    BACKPRESSURE = "backpressure"
+    # Always On
+    ALWAYS = "always"
+
+
 class OutputWavefrontPqControlsTypedDict(TypedDict):
     pass
 
@@ -201,16 +201,6 @@ class OutputWavefrontTypedDict(TypedDict):
     r"""WaveFront API authentication token (see [here](https://docs.wavefront.com/wavefront_api.html#generating-an-api-token))"""
     text_secret: NotRequired[str]
     r"""Select or create a stored text secret"""
-    pq_strict_ordering: NotRequired[bool]
-    r"""Use FIFO (first in, first out) processing. Disable to forward new events to receivers before queue is flushed."""
-    pq_rate_per_sec: NotRequired[float]
-    r"""Throttling rate (in events per second) to impose while writing to Destinations from PQ. Defaults to 0, which disables throttling."""
-    pq_mode: NotRequired[OutputWavefrontMode]
-    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
-    pq_max_buffer_size: NotRequired[float]
-    r"""The maximum number of events to hold in memory before writing the events to disk"""
-    pq_max_backpressure_sec: NotRequired[float]
-    r"""How long (in seconds) to wait for backpressure to resolve before engaging the queue"""
     pq_max_file_size: NotRequired[str]
     r"""The maximum size to store in each queue file before closing and optionally compressing (KB, MB, etc.)"""
     pq_max_size: NotRequired[str]
@@ -221,6 +211,8 @@ class OutputWavefrontTypedDict(TypedDict):
     r"""Codec to use to compress the persisted data"""
     pq_on_backpressure: NotRequired[OutputWavefrontQueueFullBehavior]
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
+    pq_mode: NotRequired[OutputWavefrontMode]
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
     pq_controls: NotRequired[OutputWavefrontPqControlsTypedDict]
 
 
@@ -346,34 +338,6 @@ class OutputWavefront(BaseModel):
     text_secret: Annotated[Optional[str], pydantic.Field(alias="textSecret")] = None
     r"""Select or create a stored text secret"""
 
-    pq_strict_ordering: Annotated[
-        Optional[bool], pydantic.Field(alias="pqStrictOrdering")
-    ] = True
-    r"""Use FIFO (first in, first out) processing. Disable to forward new events to receivers before queue is flushed."""
-
-    pq_rate_per_sec: Annotated[
-        Optional[float], pydantic.Field(alias="pqRatePerSec")
-    ] = 0
-    r"""Throttling rate (in events per second) to impose while writing to Destinations from PQ. Defaults to 0, which disables throttling."""
-
-    pq_mode: Annotated[
-        Annotated[
-            Optional[OutputWavefrontMode], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="pqMode"),
-    ] = OutputWavefrontMode.ERROR
-    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
-
-    pq_max_buffer_size: Annotated[
-        Optional[float], pydantic.Field(alias="pqMaxBufferSize")
-    ] = 42
-    r"""The maximum number of events to hold in memory before writing the events to disk"""
-
-    pq_max_backpressure_sec: Annotated[
-        Optional[float], pydantic.Field(alias="pqMaxBackpressureSec")
-    ] = 30
-    r"""How long (in seconds) to wait for backpressure to resolve before engaging the queue"""
-
     pq_max_file_size: Annotated[
         Optional[str], pydantic.Field(alias="pqMaxFileSize")
     ] = "1 MB"
@@ -405,6 +369,14 @@ class OutputWavefront(BaseModel):
     ] = OutputWavefrontQueueFullBehavior.BLOCK
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
 
+    pq_mode: Annotated[
+        Annotated[
+            Optional[OutputWavefrontMode], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="pqMode"),
+    ] = OutputWavefrontMode.ERROR
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
+
     pq_controls: Annotated[
         Optional[OutputWavefrontPqControls], pydantic.Field(alias="pqControls")
     ] = None

cribl_control_plane/models/outputwebhook.py

@@ -212,17 +212,6 @@ class OutputWebhookTLSSettingsClientSide(BaseModel):
     ] = None
 
 
-class OutputWebhookMode(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
-
-    # Error
-    ERROR = "error"
-    # Backpressure
-    ALWAYS = "always"
-    # Always On
-    BACKPRESSURE = "backpressure"
-
-
 class OutputWebhookCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
@@ -241,6 +230,17 @@ class OutputWebhookQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     DROP = "drop"
 
 
+class OutputWebhookMode(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
+
+    # Error
+    ERROR = "error"
+    # Backpressure
+    BACKPRESSURE = "backpressure"
+    # Always On
+    ALWAYS = "always"
+
+
 class OutputWebhookPqControlsTypedDict(TypedDict):
     pass
 
@@ -370,16 +370,6 @@ class OutputWebhookTypedDict(TypedDict):
     r"""Custom JavaScript code to format incoming event data accessible through the __e variable. The formatted content is added to (__e['__eventOut']) if available. Otherwise, the original event is serialized as JSON. Caution: This function is evaluated in an unprotected context, allowing you to execute almost any JavaScript code."""
     format_payload_code: NotRequired[str]
     r"""Optional JavaScript code to format the payload sent to the Destination. The payload, containing a batch of formatted events, is accessible through the __e['payload'] variable. The formatted payload is returned in the __e['__payloadOut'] variable. Caution: This function is evaluated in an unprotected context, allowing you to execute almost any JavaScript code."""
-    pq_strict_ordering: NotRequired[bool]
-    r"""Use FIFO (first in, first out) processing. Disable to forward new events to receivers before queue is flushed."""
-    pq_rate_per_sec: NotRequired[float]
-    r"""Throttling rate (in events per second) to impose while writing to Destinations from PQ. Defaults to 0, which disables throttling."""
-    pq_mode: NotRequired[OutputWebhookMode]
-    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
-    pq_max_buffer_size: NotRequired[float]
-    r"""The maximum number of events to hold in memory before writing the events to disk"""
-    pq_max_backpressure_sec: NotRequired[float]
-    r"""How long (in seconds) to wait for backpressure to resolve before engaging the queue"""
     pq_max_file_size: NotRequired[str]
     r"""The maximum size to store in each queue file before closing and optionally compressing (KB, MB, etc.)"""
     pq_max_size: NotRequired[str]
@@ -390,6 +380,8 @@ class OutputWebhookTypedDict(TypedDict):
     r"""Codec to use to compress the persisted data"""
     pq_on_backpressure: NotRequired[OutputWebhookQueueFullBehavior]
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
+    pq_mode: NotRequired[OutputWebhookMode]
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
     pq_controls: NotRequired[OutputWebhookPqControlsTypedDict]
     username: NotRequired[str]
     password: NotRequired[str]
@@ -607,34 +599,6 @@ class OutputWebhook(BaseModel):
     ] = None
     r"""Optional JavaScript code to format the payload sent to the Destination. The payload, containing a batch of formatted events, is accessible through the __e['payload'] variable. The formatted payload is returned in the __e['__payloadOut'] variable. Caution: This function is evaluated in an unprotected context, allowing you to execute almost any JavaScript code."""
 
-    pq_strict_ordering: Annotated[
-        Optional[bool], pydantic.Field(alias="pqStrictOrdering")
-    ] = True
-    r"""Use FIFO (first in, first out) processing. Disable to forward new events to receivers before queue is flushed."""
-
-    pq_rate_per_sec: Annotated[
-        Optional[float], pydantic.Field(alias="pqRatePerSec")
-    ] = 0
-    r"""Throttling rate (in events per second) to impose while writing to Destinations from PQ. Defaults to 0, which disables throttling."""
-
-    pq_mode: Annotated[
-        Annotated[
-            Optional[OutputWebhookMode], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="pqMode"),
-    ] = OutputWebhookMode.ERROR
-    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
-
-    pq_max_buffer_size: Annotated[
-        Optional[float], pydantic.Field(alias="pqMaxBufferSize")
-    ] = 42
-    r"""The maximum number of events to hold in memory before writing the events to disk"""
-
-    pq_max_backpressure_sec: Annotated[
-        Optional[float], pydantic.Field(alias="pqMaxBackpressureSec")
-    ] = 30
-    r"""How long (in seconds) to wait for backpressure to resolve before engaging the queue"""
-
     pq_max_file_size: Annotated[
         Optional[str], pydantic.Field(alias="pqMaxFileSize")
     ] = "1 MB"
@@ -666,6 +630,14 @@ class OutputWebhook(BaseModel):
     ] = OutputWebhookQueueFullBehavior.BLOCK
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
 
+    pq_mode: Annotated[
+        Annotated[
+            Optional[OutputWebhookMode], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="pqMode"),
+    ] = OutputWebhookMode.ERROR
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
+
     pq_controls: Annotated[
         Optional[OutputWebhookPqControls], pydantic.Field(alias="pqControls")
     ] = None

cribl_control_plane/models/outputxsiam.py

@@ -122,17 +122,6 @@ class OutputXsiamURL(BaseModel):
     r"""Assign a weight (>0) to each endpoint to indicate its traffic-handling capability"""
 
 
-class OutputXsiamMode(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
-
-    # Error
-    ERROR = "error"
-    # Backpressure
-    ALWAYS = "always"
-    # Always On
-    BACKPRESSURE = "backpressure"
-
-
 class OutputXsiamCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
@@ -151,6 +140,17 @@ class OutputXsiamQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     DROP = "drop"
 
 
+class OutputXsiamMode(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
+
+    # Error
+    ERROR = "error"
+    # Backpressure
+    BACKPRESSURE = "backpressure"
+    # Always On
+    ALWAYS = "always"
+
+
 class OutputXsiamPqControlsTypedDict(TypedDict):
     pass
 
@@ -223,16 +223,6 @@ class OutputXsiamTypedDict(TypedDict):
     r"""XSIAM authentication token"""
     text_secret: NotRequired[str]
     r"""Select or create a stored text secret"""
-    pq_strict_ordering: NotRequired[bool]
-    r"""Use FIFO (first in, first out) processing. Disable to forward new events to receivers before queue is flushed."""
-    pq_rate_per_sec: NotRequired[float]
-    r"""Throttling rate (in events per second) to impose while writing to Destinations from PQ. Defaults to 0, which disables throttling."""
-    pq_mode: NotRequired[OutputXsiamMode]
-    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
-    pq_max_buffer_size: NotRequired[float]
-    r"""The maximum number of events to hold in memory before writing the events to disk"""
-    pq_max_backpressure_sec: NotRequired[float]
-    r"""How long (in seconds) to wait for backpressure to resolve before engaging the queue"""
     pq_max_file_size: NotRequired[str]
     r"""The maximum size to store in each queue file before closing and optionally compressing (KB, MB, etc.)"""
     pq_max_size: NotRequired[str]
@@ -243,6 +233,8 @@ class OutputXsiamTypedDict(TypedDict):
     r"""Codec to use to compress the persisted data"""
     pq_on_backpressure: NotRequired[OutputXsiamQueueFullBehavior]
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
+    pq_mode: NotRequired[OutputXsiamMode]
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
     pq_controls: NotRequired[OutputXsiamPqControlsTypedDict]
 
 
@@ -395,32 +387,6 @@ class OutputXsiam(BaseModel):
     text_secret: Annotated[Optional[str], pydantic.Field(alias="textSecret")] = None
     r"""Select or create a stored text secret"""
 
-    pq_strict_ordering: Annotated[
-        Optional[bool], pydantic.Field(alias="pqStrictOrdering")
-    ] = True
-    r"""Use FIFO (first in, first out) processing. Disable to forward new events to receivers before queue is flushed."""
-
-    pq_rate_per_sec: Annotated[
-        Optional[float], pydantic.Field(alias="pqRatePerSec")
-    ] = 0
-    r"""Throttling rate (in events per second) to impose while writing to Destinations from PQ. Defaults to 0, which disables throttling."""
-
-    pq_mode: Annotated[
-        Annotated[Optional[OutputXsiamMode], PlainValidator(validate_open_enum(False))],
-        pydantic.Field(alias="pqMode"),
-    ] = OutputXsiamMode.ERROR
-    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
-
-    pq_max_buffer_size: Annotated[
-        Optional[float], pydantic.Field(alias="pqMaxBufferSize")
-    ] = 42
-    r"""The maximum number of events to hold in memory before writing the events to disk"""
-
-    pq_max_backpressure_sec: Annotated[
-        Optional[float], pydantic.Field(alias="pqMaxBackpressureSec")
-    ] = 30
-    r"""How long (in seconds) to wait for backpressure to resolve before engaging the queue"""
-
     pq_max_file_size: Annotated[
         Optional[str], pydantic.Field(alias="pqMaxFileSize")
     ] = "1 MB"
@@ -451,6 +417,12 @@ class OutputXsiam(BaseModel):
     ] = OutputXsiamQueueFullBehavior.BLOCK
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
 
+    pq_mode: Annotated[
+        Annotated[Optional[OutputXsiamMode], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="pqMode"),
+    ] = OutputXsiamMode.ERROR
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
+
     pq_controls: Annotated[
         Optional[OutputXsiamPqControls], pydantic.Field(alias="pqControls")
     ] = None

cribl_control_plane/models/runnablejobcollection.py

@@ -175,14 +175,13 @@ class RunnableJobCollectionScheduleTypedDict(TypedDict):
 
     enabled: NotRequired[bool]
     r"""Enable to configure scheduling for this Collector"""
-    skippable: NotRequired[bool]
-    r"""Skippable jobs can be delayed, up to their next run time, if the system is hitting concurrency limits"""
-    resume_missed: NotRequired[bool]
-    r"""If Stream Leader (or single instance) restarts, run all missed jobs according to their original schedules"""
     cron_schedule: NotRequired[str]
     r"""A cron schedule on which to run this job"""
     max_concurrent_runs: NotRequired[float]
     r"""The maximum number of instances of this scheduled job that may be running at any time"""
+    skippable: NotRequired[bool]
+    r"""Skippable jobs can be delayed, up to their next run time, if the system is hitting concurrency limits"""
+    resume_missed: NotRequired[Any]
     run: NotRequired[RunnableJobCollectionRunSettingsTypedDict]
 
 
@@ -192,14 +191,6 @@ class RunnableJobCollectionSchedule(BaseModel):
     enabled: Optional[bool] = None
     r"""Enable to configure scheduling for this Collector"""
 
-    skippable: Optional[bool] = True
-    r"""Skippable jobs can be delayed, up to their next run time, if the system is hitting concurrency limits"""
-
-    resume_missed: Annotated[Optional[bool], pydantic.Field(alias="resumeMissed")] = (
-        False
-    )
-    r"""If Stream Leader (or single instance) restarts, run all missed jobs according to their original schedules"""
-
     cron_schedule: Annotated[Optional[str], pydantic.Field(alias="cronSchedule")] = (
         "*/5 * * * *"
     )
@@ -210,6 +201,11 @@ class RunnableJobCollectionSchedule(BaseModel):
     ] = 1
     r"""The maximum number of instances of this scheduled job that may be running at any time"""
 
+    skippable: Optional[bool] = True
+    r"""Skippable jobs can be delayed, up to their next run time, if the system is hitting concurrency limits"""
+
+    resume_missed: Annotated[Optional[Any], pydantic.Field(alias="resumeMissed")] = None
+
     run: Optional[RunnableJobCollectionRunSettings] = None
 
 

cribl_control_plane/models/runnablejobexecutor.py

@@ -173,14 +173,13 @@ class RunnableJobExecutorScheduleTypedDict(TypedDict):
 
     enabled: NotRequired[bool]
     r"""Enable to configure scheduling for this Collector"""
-    skippable: NotRequired[bool]
-    r"""Skippable jobs can be delayed, up to their next run time, if the system is hitting concurrency limits"""
-    resume_missed: NotRequired[bool]
-    r"""If Stream Leader (or single instance) restarts, run all missed jobs according to their original schedules"""
     cron_schedule: NotRequired[str]
     r"""A cron schedule on which to run this job"""
     max_concurrent_runs: NotRequired[float]
     r"""The maximum number of instances of this scheduled job that may be running at any time"""
+    skippable: NotRequired[bool]
+    r"""Skippable jobs can be delayed, up to their next run time, if the system is hitting concurrency limits"""
+    resume_missed: NotRequired[Any]
     run: NotRequired[RunnableJobExecutorRunSettingsTypedDict]
 
 
@@ -190,14 +189,6 @@ class RunnableJobExecutorSchedule(BaseModel):
     enabled: Optional[bool] = None
     r"""Enable to configure scheduling for this Collector"""
 
-    skippable: Optional[bool] = True
-    r"""Skippable jobs can be delayed, up to their next run time, if the system is hitting concurrency limits"""
-
-    resume_missed: Annotated[Optional[bool], pydantic.Field(alias="resumeMissed")] = (
-        False
-    )
-    r"""If Stream Leader (or single instance) restarts, run all missed jobs according to their original schedules"""
-
     cron_schedule: Annotated[Optional[str], pydantic.Field(alias="cronSchedule")] = (
         "*/5 * * * *"
     )
@@ -208,6 +199,11 @@ class RunnableJobExecutorSchedule(BaseModel):
     ] = 1
     r"""The maximum number of instances of this scheduled job that may be running at any time"""
 
+    skippable: Optional[bool] = True
+    r"""Skippable jobs can be delayed, up to their next run time, if the system is hitting concurrency limits"""
+
+    resume_missed: Annotated[Optional[Any], pydantic.Field(alias="resumeMissed")] = None
+
     run: Optional[RunnableJobExecutorRunSettings] = None
 
 

cribl_control_plane/models/runnablejobscheduledsearch.py

@@ -174,14 +174,13 @@ class RunnableJobScheduledSearchScheduleTypedDict(TypedDict):
 
     enabled: NotRequired[bool]
     r"""Enable to configure scheduling for this Collector"""
-    skippable: NotRequired[bool]
-    r"""Skippable jobs can be delayed, up to their next run time, if the system is hitting concurrency limits"""
-    resume_missed: NotRequired[bool]
-    r"""If Stream Leader (or single instance) restarts, run all missed jobs according to their original schedules"""
     cron_schedule: NotRequired[str]
     r"""A cron schedule on which to run this job"""
     max_concurrent_runs: NotRequired[float]
     r"""The maximum number of instances of this scheduled job that may be running at any time"""
+    skippable: NotRequired[bool]
+    r"""Skippable jobs can be delayed, up to their next run time, if the system is hitting concurrency limits"""
+    resume_missed: NotRequired[Any]
     run: NotRequired[RunnableJobScheduledSearchRunSettingsTypedDict]
 
 
@@ -191,14 +190,6 @@ class RunnableJobScheduledSearchSchedule(BaseModel):
     enabled: Optional[bool] = None
     r"""Enable to configure scheduling for this Collector"""
 
-    skippable: Optional[bool] = True
-    r"""Skippable jobs can be delayed, up to their next run time, if the system is hitting concurrency limits"""
-
-    resume_missed: Annotated[Optional[bool], pydantic.Field(alias="resumeMissed")] = (
-        False
-    )
-    r"""If Stream Leader (or single instance) restarts, run all missed jobs according to their original schedules"""
-
     cron_schedule: Annotated[Optional[str], pydantic.Field(alias="cronSchedule")] = (
         "*/5 * * * *"
     )
@@ -209,6 +200,11 @@ class RunnableJobScheduledSearchSchedule(BaseModel):
     ] = 1
     r"""The maximum number of instances of this scheduled job that may be running at any time"""
 
+    skippable: Optional[bool] = True
+    r"""Skippable jobs can be delayed, up to their next run time, if the system is hitting concurrency limits"""
+
+    resume_missed: Annotated[Optional[Any], pydantic.Field(alias="resumeMissed")] = None
+
     run: Optional[RunnableJobScheduledSearchRunSettings] = None
 
 

{cribl_control_plane-0.2.1rc4.dist-info → cribl_control_plane-0.2.1rc6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cribl-control-plane
-Version: 0.2.1rc4
+Version: 0.2.1rc6
 Summary: Python Client SDK Generated by Speakeasy.
 Author: Speakeasy
 Requires-Python: >=3.9.2