cribl-control-plane 0.0.31__py3-none-any.whl → 0.0.33__py3-none-any.whl

cribl_control_plane/models/gitsettings.py

@@ -0,0 +1,70 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .gitopstype import GitOpsType
+from cribl_control_plane.types import BaseModel
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class GitSettingsTypedDict(TypedDict):
+    auth_type: NotRequired[str]
+    auto_action: NotRequired[str]
+    auto_action_message: NotRequired[str]
+    auto_action_schedule: NotRequired[str]
+    branch: NotRequired[str]
+    commit_deploy_single_action: NotRequired[bool]
+    copilot_auto_git_commit_messages: NotRequired[bool]
+    default_commit_message: NotRequired[str]
+    git_ops: NotRequired[GitOpsType]
+    password: NotRequired[str]
+    remote: NotRequired[str]
+    ssh_key: NotRequired[str]
+    strict_host_key_checking: NotRequired[bool]
+    timeout: NotRequired[float]
+    user: NotRequired[str]
+
+
+class GitSettings(BaseModel):
+    auth_type: Annotated[Optional[str], pydantic.Field(alias="authType")] = None
+
+    auto_action: Annotated[Optional[str], pydantic.Field(alias="autoAction")] = None
+
+    auto_action_message: Annotated[
+        Optional[str], pydantic.Field(alias="autoActionMessage")
+    ] = None
+
+    auto_action_schedule: Annotated[
+        Optional[str], pydantic.Field(alias="autoActionSchedule")
+    ] = None
+
+    branch: Optional[str] = None
+
+    commit_deploy_single_action: Annotated[
+        Optional[bool], pydantic.Field(alias="commitDeploySingleAction")
+    ] = None
+
+    copilot_auto_git_commit_messages: Annotated[
+        Optional[bool], pydantic.Field(alias="copilotAutoGitCommitMessages")
+    ] = None
+
+    default_commit_message: Annotated[
+        Optional[str], pydantic.Field(alias="defaultCommitMessage")
+    ] = None
+
+    git_ops: Annotated[Optional[GitOpsType], pydantic.Field(alias="gitOps")] = None
+
+    password: Optional[str] = None
+
+    remote: Optional[str] = None
+
+    ssh_key: Annotated[Optional[str], pydantic.Field(alias="sshKey")] = None
+
+    strict_host_key_checking: Annotated[
+        Optional[bool], pydantic.Field(alias="strictHostKeyChecking")
+    ] = None
+
+    timeout: Optional[float] = None
+
+    user: Optional[str] = None

cribl_control_plane/models/jobsettings.py

@@ -0,0 +1,83 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class JobSettingsTypedDict(TypedDict):
+    concurrent_job_limit: float
+    concurrent_scheduled_job_limit: float
+    concurrent_system_job_limit: float
+    concurrent_system_task_limit: float
+    concurrent_task_limit: float
+    finished_job_artifacts_limit: float
+    finished_task_artifacts_limit: float
+    job_artifacts_reaper_period: str
+    job_timeout: str
+    max_task_perc: float
+    scheduling_policy: str
+    task_heartbeat_period: float
+    task_manifest_flush_period_ms: float
+    task_manifest_max_buffer_size: float
+    task_manifest_read_buffer_size: str
+    task_poll_timeout_ms: float
+    disable_tasks: NotRequired[bool]
+
+
+class JobSettings(BaseModel):
+    concurrent_job_limit: Annotated[float, pydantic.Field(alias="concurrentJobLimit")]
+
+    concurrent_scheduled_job_limit: Annotated[
+        float, pydantic.Field(alias="concurrentScheduledJobLimit")
+    ]
+
+    concurrent_system_job_limit: Annotated[
+        float, pydantic.Field(alias="concurrentSystemJobLimit")
+    ]
+
+    concurrent_system_task_limit: Annotated[
+        float, pydantic.Field(alias="concurrentSystemTaskLimit")
+    ]
+
+    concurrent_task_limit: Annotated[float, pydantic.Field(alias="concurrentTaskLimit")]
+
+    finished_job_artifacts_limit: Annotated[
+        float, pydantic.Field(alias="finishedJobArtifactsLimit")
+    ]
+
+    finished_task_artifacts_limit: Annotated[
+        float, pydantic.Field(alias="finishedTaskArtifactsLimit")
+    ]
+
+    job_artifacts_reaper_period: Annotated[
+        str, pydantic.Field(alias="jobArtifactsReaperPeriod")
+    ]
+
+    job_timeout: Annotated[str, pydantic.Field(alias="jobTimeout")]
+
+    max_task_perc: Annotated[float, pydantic.Field(alias="maxTaskPerc")]
+
+    scheduling_policy: Annotated[str, pydantic.Field(alias="schedulingPolicy")]
+
+    task_heartbeat_period: Annotated[float, pydantic.Field(alias="taskHeartbeatPeriod")]
+
+    task_manifest_flush_period_ms: Annotated[
+        float, pydantic.Field(alias="taskManifestFlushPeriodMs")
+    ]
+
+    task_manifest_max_buffer_size: Annotated[
+        float, pydantic.Field(alias="taskManifestMaxBufferSize")
+    ]
+
+    task_manifest_read_buffer_size: Annotated[
+        str, pydantic.Field(alias="taskManifestReadBufferSize")
+    ]
+
+    task_poll_timeout_ms: Annotated[float, pydantic.Field(alias="taskPollTimeoutMs")]
+
+    disable_tasks: Annotated[Optional[bool], pydantic.Field(alias="disableTasks")] = (
+        None
+    )

cribl_control_plane/models/limits.py

@@ -0,0 +1,127 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .edgeheartbeatmetricsmode import EdgeHeartbeatMetricsMode
+from cribl_control_plane.types import BaseModel
+import pydantic
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class SamplesTypedDict(TypedDict):
+    max_size: str
+
+
+class Samples(BaseModel):
+    max_size: Annotated[str, pydantic.Field(alias="maxSize")]
+
+
+class LimitsTypedDict(TypedDict):
+    cpu_profile_ttl: str
+    enable_metrics_persistence: bool
+    metrics_directory: str
+    metrics_fields_blacklist: List[str]
+    metrics_gc_period: str
+    metrics_never_drop_list: List[str]
+    metrics_worker_id_blacklist: List[str]
+    min_free_space: str
+    samples: SamplesTypedDict
+    disable_metrics_accessor_cache: NotRequired[bool]
+    edge_metrics_custom_expression: NotRequired[str]
+    edge_metrics_mode: NotRequired[EdgeHeartbeatMetricsMode]
+    edge_nodes_count: NotRequired[float]
+    enable_worker_persistence: NotRequired[bool]
+    events_metadata_sources: NotRequired[List[str]]
+    large_events_threshold: NotRequired[str]
+    lookup_max_size: NotRequired[str]
+    lookup_max_total_size: NotRequired[str]
+    max_metrics: NotRequired[float]
+    max_pq_size: NotRequired[str]
+    metrics_drop_list: NotRequired[List[str]]
+    metrics_max_cardinality: NotRequired[float]
+    metrics_max_disk_space: NotRequired[str]
+    worker_max_metrics: NotRequired[float]
+
+
+class Limits(BaseModel):
+    cpu_profile_ttl: Annotated[str, pydantic.Field(alias="cpuProfileTTL")]
+
+    enable_metrics_persistence: Annotated[
+        bool, pydantic.Field(alias="enableMetricsPersistence")
+    ]
+
+    metrics_directory: Annotated[str, pydantic.Field(alias="metricsDirectory")]
+
+    metrics_fields_blacklist: Annotated[
+        List[str], pydantic.Field(alias="metricsFieldsBlacklist")
+    ]
+
+    metrics_gc_period: Annotated[str, pydantic.Field(alias="metricsGCPeriod")]
+
+    metrics_never_drop_list: Annotated[
+        List[str], pydantic.Field(alias="metricsNeverDropList")
+    ]
+
+    metrics_worker_id_blacklist: Annotated[
+        List[str], pydantic.Field(alias="metricsWorkerIdBlacklist")
+    ]
+
+    min_free_space: Annotated[str, pydantic.Field(alias="minFreeSpace")]
+
+    samples: Samples
+
+    disable_metrics_accessor_cache: Annotated[
+        Optional[bool], pydantic.Field(alias="disableMetricsAccessorCache")
+    ] = None
+
+    edge_metrics_custom_expression: Annotated[
+        Optional[str], pydantic.Field(alias="edgeMetricsCustomExpression")
+    ] = None
+
+    edge_metrics_mode: Annotated[
+        Optional[EdgeHeartbeatMetricsMode], pydantic.Field(alias="edgeMetricsMode")
+    ] = None
+
+    edge_nodes_count: Annotated[
+        Optional[float], pydantic.Field(alias="edgeNodesCount")
+    ] = None
+
+    enable_worker_persistence: Annotated[
+        Optional[bool], pydantic.Field(alias="enableWorkerPersistence")
+    ] = None
+
+    events_metadata_sources: Annotated[
+        Optional[List[str]], pydantic.Field(alias="eventsMetadataSources")
+    ] = None
+
+    large_events_threshold: Annotated[
+        Optional[str], pydantic.Field(alias="largeEventsThreshold")
+    ] = None
+
+    lookup_max_size: Annotated[Optional[str], pydantic.Field(alias="lookupMaxSize")] = (
+        None
+    )
+
+    lookup_max_total_size: Annotated[
+        Optional[str], pydantic.Field(alias="lookupMaxTotalSize")
+    ] = None
+
+    max_metrics: Annotated[Optional[float], pydantic.Field(alias="maxMetrics")] = None
+
+    max_pq_size: Annotated[Optional[str], pydantic.Field(alias="maxPQSize")] = None
+
+    metrics_drop_list: Annotated[
+        Optional[List[str]], pydantic.Field(alias="metricsDropList")
+    ] = None
+
+    metrics_max_cardinality: Annotated[
+        Optional[float], pydantic.Field(alias="metricsMaxCardinality")
+    ] = None
+
+    metrics_max_disk_space: Annotated[
+        Optional[str], pydantic.Field(alias="metricsMaxDiskSpace")
+    ] = None
+
+    worker_max_metrics: Annotated[
+        Optional[float], pydantic.Field(alias="workerMaxMetrics")
+    ] = None

cribl_control_plane/models/listmasterworkerentryop.py

@@ -11,17 +11,17 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 
 class ListMasterWorkerEntryRequestTypedDict(TypedDict):
     filter_exp: NotRequired[str]
-    r"""Filter expression evaluated against nodes"""
-    sort: NotRequired[str]
-    r"""Sorting object (JSON stringified) expression evaluated against nodes"""
+    r"""Filter expression to evaluate against Nodes for inclusion in the response."""
     sort_exp: NotRequired[str]
-    r"""Sorting expression evaluated against nodes"""
+    r"""Sorting expression to evaluate against Nodes to specify the sort order for the response."""
+    filter_: NotRequired[str]
+    r"""JSON-stringified filter object to evaluate against Nodes for inclusion in the response."""
+    sort: NotRequired[str]
+    r"""JSON-stringified sorting object to evaluate against Nodes to specify the sort order for the response."""
     limit: NotRequired[int]
-    r"""Maximum number of nodes to return"""
+    r"""Maximum number of Nodes to return in the response for this request. Use with <code>offset</code> to paginate the response into manageable batches."""
     offset: NotRequired[int]
-    r"""Pagination offset"""
-    filter_: NotRequired[str]
-    r"""Filter object (JSON stringified) to select nodes"""
+    r"""Starting point from which to retrieve results for this request. Use with <code>limit</code> to paginate the response into manageable batches."""
 
 
 class ListMasterWorkerEntryRequest(BaseModel):
@@ -30,39 +30,39 @@ class ListMasterWorkerEntryRequest(BaseModel):
         pydantic.Field(alias="filterExp"),
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = None
-    r"""Filter expression evaluated against nodes"""
+    r"""Filter expression to evaluate against Nodes for inclusion in the response."""
 
-    sort: Annotated[
+    sort_exp: Annotated[
         Optional[str],
+        pydantic.Field(alias="sortExp"),
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = None
-    r"""Sorting object (JSON stringified) expression evaluated against nodes"""
+    r"""Sorting expression to evaluate against Nodes to specify the sort order for the response."""
 
-    sort_exp: Annotated[
+    filter_: Annotated[
         Optional[str],
-        pydantic.Field(alias="sortExp"),
+        pydantic.Field(alias="filter"),
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = None
-    r"""Sorting expression evaluated against nodes"""
+    r"""JSON-stringified filter object to evaluate against Nodes for inclusion in the response."""
 
-    limit: Annotated[
-        Optional[int],
+    sort: Annotated[
+        Optional[str],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = None
-    r"""Maximum number of nodes to return"""
+    r"""JSON-stringified sorting object to evaluate against Nodes to specify the sort order for the response."""
 
-    offset: Annotated[
+    limit: Annotated[
         Optional[int],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = None
-    r"""Pagination offset"""
+    r"""Maximum number of Nodes to return in the response for this request. Use with <code>offset</code> to paginate the response into manageable batches."""
 
-    filter_: Annotated[
-        Optional[str],
-        pydantic.Field(alias="filter"),
+    offset: Annotated[
+        Optional[int],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = None
-    r"""Filter object (JSON stringified) to select nodes"""
+    r"""Starting point from which to retrieve results for this request. Use with <code>limit</code> to paginate the response into manageable batches."""
 
 
 class ListMasterWorkerEntryResponseTypedDict(TypedDict):

cribl_control_plane/models/rediscachelimits.py

@@ -0,0 +1,38 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class RedisCacheLimitsTypedDict(TypedDict):
+    client_tracking_mechanism: NotRequired[str]
+    enable_server_assist: NotRequired[bool]
+    key_ttl_secs: NotRequired[float]
+    max_cache_size: NotRequired[float]
+    max_num_keys: NotRequired[float]
+    service_period_secs: NotRequired[float]
+
+
+class RedisCacheLimits(BaseModel):
+    client_tracking_mechanism: Annotated[
+        Optional[str], pydantic.Field(alias="clientTrackingMechanism")
+    ] = None
+
+    enable_server_assist: Annotated[
+        Optional[bool], pydantic.Field(alias="enableServerAssist")
+    ] = None
+
+    key_ttl_secs: Annotated[Optional[float], pydantic.Field(alias="keyTTLSecs")] = None
+
+    max_cache_size: Annotated[Optional[float], pydantic.Field(alias="maxCacheSize")] = (
+        None
+    )
+
+    max_num_keys: Annotated[Optional[float], pydantic.Field(alias="maxNumKeys")] = None
+
+    service_period_secs: Annotated[
+        Optional[float], pydantic.Field(alias="servicePeriodSecs")
+    ] = None

cribl_control_plane/models/redisconnectionlimits.py

@@ -0,0 +1,20 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class RedisConnectionLimitsTypedDict(TypedDict):
+    disabled: NotRequired[bool]
+    max_connections: NotRequired[float]
+
+
+class RedisConnectionLimits(BaseModel):
+    disabled: Optional[bool] = None
+
+    max_connections: Annotated[
+        Optional[float], pydantic.Field(alias="maxConnections")
+    ] = None

cribl_control_plane/models/redislimits.py

@@ -0,0 +1,14 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .redisconnectionlimits import RedisConnectionLimits, RedisConnectionLimitsTypedDict
+from cribl_control_plane.types import BaseModel
+from typing_extensions import TypedDict
+
+
+class RedisLimitsTypedDict(TypedDict):
+    connections: RedisConnectionLimitsTypedDict
+
+
+class RedisLimits(BaseModel):
+    connections: RedisConnectionLimits

cribl_control_plane/models/searchsettings.py

@@ -0,0 +1,71 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+from enum import Enum
+import pydantic
+from typing import Union
+from typing_extensions import Annotated, TypeAliasType, TypedDict
+
+
+class WarmPoolSizeEnum(str, Enum):
+    AUTO = "auto"
+
+
+WarmPoolSizeTypedDict = TypeAliasType(
+    "WarmPoolSizeTypedDict", Union[float, WarmPoolSizeEnum]
+)
+
+
+WarmPoolSize = TypeAliasType("WarmPoolSize", Union[float, WarmPoolSizeEnum])
+
+
+class SearchSettingsTypedDict(TypedDict):
+    compress_object_cache_artifacts: bool
+    field_summary_max_fields: float
+    field_summary_max_nested_depth: float
+    max_concurrent_searches: float
+    max_executors_per_search: float
+    max_results_per_search: float
+    search_history_max_jobs: float
+    search_queue_length: float
+    warm_pool_size: WarmPoolSizeTypedDict
+    write_only_provider_secrets: bool
+
+
+class SearchSettings(BaseModel):
+    compress_object_cache_artifacts: Annotated[
+        bool, pydantic.Field(alias="compressObjectCacheArtifacts")
+    ]
+
+    field_summary_max_fields: Annotated[
+        float, pydantic.Field(alias="fieldSummaryMaxFields")
+    ]
+
+    field_summary_max_nested_depth: Annotated[
+        float, pydantic.Field(alias="fieldSummaryMaxNestedDepth")
+    ]
+
+    max_concurrent_searches: Annotated[
+        float, pydantic.Field(alias="maxConcurrentSearches")
+    ]
+
+    max_executors_per_search: Annotated[
+        float, pydantic.Field(alias="maxExecutorsPerSearch")
+    ]
+
+    max_results_per_search: Annotated[
+        float, pydantic.Field(alias="maxResultsPerSearch")
+    ]
+
+    search_history_max_jobs: Annotated[
+        float, pydantic.Field(alias="searchHistoryMaxJobs")
+    ]
+
+    search_queue_length: Annotated[float, pydantic.Field(alias="searchQueueLength")]
+
+    warm_pool_size: Annotated[WarmPoolSize, pydantic.Field(alias="warmPoolSize")]
+
+    write_only_provider_secrets: Annotated[
+        bool, pydantic.Field(alias="writeOnlyProviderSecrets")
+    ]

cribl_control_plane/models/serviceslimits.py

@@ -0,0 +1,23 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .commonservicelimitconfigs import (
+    CommonServiceLimitConfigs,
+    CommonServiceLimitConfigsTypedDict,
+)
+from cribl_control_plane.types import BaseModel
+from typing_extensions import TypedDict
+
+
+class ServicesLimitsTypedDict(TypedDict):
+    connections: CommonServiceLimitConfigsTypedDict
+    metrics: CommonServiceLimitConfigsTypedDict
+    notifications: CommonServiceLimitConfigsTypedDict
+
+
+class ServicesLimits(BaseModel):
+    connections: CommonServiceLimitConfigs
+
+    metrics: CommonServiceLimitConfigs
+
+    notifications: CommonServiceLimitConfigs