# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import builtins
import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities

__all__ = [
    'WorkspaceInstanceTypeArgs',
    'WorkspaceInstanceTypeArgsDict',
    'WorkspaceQuotaArgs',
    'WorkspaceQuotaArgsDict',
    'WorkspaceTagArgs',
    'WorkspaceTagArgsDict',
    'WorkspaceUsageArgs',
    'WorkspaceUsageArgsDict',
]

MYPY = False

if not MYPY:
    class WorkspaceInstanceTypeArgsDict(TypedDict):
        active_series: NotRequired[pulumi.Input[builtins.int]]
        """
        最大活跃时序数。
        """
        availability_zone_replicas: NotRequired[pulumi.Input[builtins.int]]
        """
        可用区（az）数。
        """
        downsampling_periods: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        降采样策略。
        """
        ingest_samples_per_second: NotRequired[pulumi.Input[builtins.int]]
        """
        最大每秒写入样本数。
        """
        query_concurrency: NotRequired[pulumi.Input[builtins.int]]
        """
        最大查询并发数。
        """
        query_per_second: NotRequired[pulumi.Input[builtins.int]]
        """
        最大查询 QPS。
        """
        replicas_per_zone: NotRequired[pulumi.Input[builtins.int]]
        """
        每个可用区（az）的数据副本数。
        """
        retention_period: NotRequired[pulumi.Input[builtins.str]]
        """
        最长数据保留时间。
        """
        scan_samples_per_second: NotRequired[pulumi.Input[builtins.int]]
        """
        最大每秒扫描样本数。
        """
        scan_series_per_second: NotRequired[pulumi.Input[builtins.int]]
        """
        最大每秒扫描时序数。
        """
elif False:
    WorkspaceInstanceTypeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class WorkspaceInstanceTypeArgs:
    def __init__(__self__, *,
                 active_series: Optional[pulumi.Input[builtins.int]] = None,
                 availability_zone_replicas: Optional[pulumi.Input[builtins.int]] = None,
                 downsampling_periods: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 ingest_samples_per_second: Optional[pulumi.Input[builtins.int]] = None,
                 query_concurrency: Optional[pulumi.Input[builtins.int]] = None,
                 query_per_second: Optional[pulumi.Input[builtins.int]] = None,
                 replicas_per_zone: Optional[pulumi.Input[builtins.int]] = None,
                 retention_period: Optional[pulumi.Input[builtins.str]] = None,
                 scan_samples_per_second: Optional[pulumi.Input[builtins.int]] = None,
                 scan_series_per_second: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.int] active_series: 最大活跃时序数。
        :param pulumi.Input[builtins.int] availability_zone_replicas: 可用区（az）数。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] downsampling_periods: 降采样策略。
        :param pulumi.Input[builtins.int] ingest_samples_per_second: 最大每秒写入样本数。
        :param pulumi.Input[builtins.int] query_concurrency: 最大查询并发数。
        :param pulumi.Input[builtins.int] query_per_second: 最大查询 QPS。
        :param pulumi.Input[builtins.int] replicas_per_zone: 每个可用区（az）的数据副本数。
        :param pulumi.Input[builtins.str] retention_period: 最长数据保留时间。
        :param pulumi.Input[builtins.int] scan_samples_per_second: 最大每秒扫描样本数。
        :param pulumi.Input[builtins.int] scan_series_per_second: 最大每秒扫描时序数。
        """
        if active_series is not None:
            pulumi.set(__self__, "active_series", active_series)
        if availability_zone_replicas is not None:
            pulumi.set(__self__, "availability_zone_replicas", availability_zone_replicas)
        if downsampling_periods is not None:
            pulumi.set(__self__, "downsampling_periods", downsampling_periods)
        if ingest_samples_per_second is not None:
            pulumi.set(__self__, "ingest_samples_per_second", ingest_samples_per_second)
        if query_concurrency is not None:
            pulumi.set(__self__, "query_concurrency", query_concurrency)
        if query_per_second is not None:
            pulumi.set(__self__, "query_per_second", query_per_second)
        if replicas_per_zone is not None:
            pulumi.set(__self__, "replicas_per_zone", replicas_per_zone)
        if retention_period is not None:
            pulumi.set(__self__, "retention_period", retention_period)
        if scan_samples_per_second is not None:
            pulumi.set(__self__, "scan_samples_per_second", scan_samples_per_second)
        if scan_series_per_second is not None:
            pulumi.set(__self__, "scan_series_per_second", scan_series_per_second)

    @property
    @pulumi.getter(name="activeSeries")
    def active_series(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        最大活跃时序数。
        """
        return pulumi.get(self, "active_series")

    @active_series.setter
    def active_series(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "active_series", value)

    @property
    @pulumi.getter(name="availabilityZoneReplicas")
    def availability_zone_replicas(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        可用区（az）数。
        """
        return pulumi.get(self, "availability_zone_replicas")

    @availability_zone_replicas.setter
    def availability_zone_replicas(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "availability_zone_replicas", value)

    @property
    @pulumi.getter(name="downsamplingPeriods")
    def downsampling_periods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        降采样策略。
        """
        return pulumi.get(self, "downsampling_periods")

    @downsampling_periods.setter
    def downsampling_periods(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "downsampling_periods", value)

    @property
    @pulumi.getter(name="ingestSamplesPerSecond")
    def ingest_samples_per_second(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        最大每秒写入样本数。
        """
        return pulumi.get(self, "ingest_samples_per_second")

    @ingest_samples_per_second.setter
    def ingest_samples_per_second(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "ingest_samples_per_second", value)

    @property
    @pulumi.getter(name="queryConcurrency")
    def query_concurrency(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        最大查询并发数。
        """
        return pulumi.get(self, "query_concurrency")

    @query_concurrency.setter
    def query_concurrency(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "query_concurrency", value)

    @property
    @pulumi.getter(name="queryPerSecond")
    def query_per_second(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        最大查询 QPS。
        """
        return pulumi.get(self, "query_per_second")

    @query_per_second.setter
    def query_per_second(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "query_per_second", value)

    @property
    @pulumi.getter(name="replicasPerZone")
    def replicas_per_zone(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        每个可用区（az）的数据副本数。
        """
        return pulumi.get(self, "replicas_per_zone")

    @replicas_per_zone.setter
    def replicas_per_zone(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "replicas_per_zone", value)

    @property
    @pulumi.getter(name="retentionPeriod")
    def retention_period(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        最长数据保留时间。
        """
        return pulumi.get(self, "retention_period")

    @retention_period.setter
    def retention_period(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "retention_period", value)

    @property
    @pulumi.getter(name="scanSamplesPerSecond")
    def scan_samples_per_second(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        最大每秒扫描样本数。
        """
        return pulumi.get(self, "scan_samples_per_second")

    @scan_samples_per_second.setter
    def scan_samples_per_second(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "scan_samples_per_second", value)

    @property
    @pulumi.getter(name="scanSeriesPerSecond")
    def scan_series_per_second(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        最大每秒扫描时序数。
        """
        return pulumi.get(self, "scan_series_per_second")

    @scan_series_per_second.setter
    def scan_series_per_second(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "scan_series_per_second", value)


if not MYPY:
    class WorkspaceQuotaArgsDict(TypedDict):
        active_series: NotRequired[pulumi.Input[builtins.int]]
        """
        最大活跃时序数。整数形式，默认取值范围为 1～50000000。
        """
        ingest_samples_per_second: NotRequired[pulumi.Input[builtins.int]]
        """
        指标摄入速率，即最大每秒写入样本数。整数形式，默认取值范围为 1～5000000。
        """
        query_per_second: NotRequired[pulumi.Input[builtins.int]]
        """
        最大查询 QPS。整数形式，默认取值范围为 1～500。
        """
        scan_samples_per_second: NotRequired[pulumi.Input[builtins.int]]
        """
        最大每秒扫描样本数。整数形式，默认取值范围为 1～1000000000。
        """
        scan_series_per_second: NotRequired[pulumi.Input[builtins.int]]
        """
        最大每秒扫描时序数。整数形式，默认取值范围为 1～200000。
        """
elif False:
    WorkspaceQuotaArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class WorkspaceQuotaArgs:
    def __init__(__self__, *,
                 active_series: Optional[pulumi.Input[builtins.int]] = None,
                 ingest_samples_per_second: Optional[pulumi.Input[builtins.int]] = None,
                 query_per_second: Optional[pulumi.Input[builtins.int]] = None,
                 scan_samples_per_second: Optional[pulumi.Input[builtins.int]] = None,
                 scan_series_per_second: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.int] active_series: 最大活跃时序数。整数形式，默认取值范围为 1～50000000。
        :param pulumi.Input[builtins.int] ingest_samples_per_second: 指标摄入速率，即最大每秒写入样本数。整数形式，默认取值范围为 1～5000000。
        :param pulumi.Input[builtins.int] query_per_second: 最大查询 QPS。整数形式，默认取值范围为 1～500。
        :param pulumi.Input[builtins.int] scan_samples_per_second: 最大每秒扫描样本数。整数形式，默认取值范围为 1～1000000000。
        :param pulumi.Input[builtins.int] scan_series_per_second: 最大每秒扫描时序数。整数形式，默认取值范围为 1～200000。
        """
        if active_series is not None:
            pulumi.set(__self__, "active_series", active_series)
        if ingest_samples_per_second is not None:
            pulumi.set(__self__, "ingest_samples_per_second", ingest_samples_per_second)
        if query_per_second is not None:
            pulumi.set(__self__, "query_per_second", query_per_second)
        if scan_samples_per_second is not None:
            pulumi.set(__self__, "scan_samples_per_second", scan_samples_per_second)
        if scan_series_per_second is not None:
            pulumi.set(__self__, "scan_series_per_second", scan_series_per_second)

    @property
    @pulumi.getter(name="activeSeries")
    def active_series(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        最大活跃时序数。整数形式，默认取值范围为 1～50000000。
        """
        return pulumi.get(self, "active_series")

    @active_series.setter
    def active_series(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "active_series", value)

    @property
    @pulumi.getter(name="ingestSamplesPerSecond")
    def ingest_samples_per_second(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        指标摄入速率，即最大每秒写入样本数。整数形式，默认取值范围为 1～5000000。
        """
        return pulumi.get(self, "ingest_samples_per_second")

    @ingest_samples_per_second.setter
    def ingest_samples_per_second(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "ingest_samples_per_second", value)

    @property
    @pulumi.getter(name="queryPerSecond")
    def query_per_second(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        最大查询 QPS。整数形式，默认取值范围为 1～500。
        """
        return pulumi.get(self, "query_per_second")

    @query_per_second.setter
    def query_per_second(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "query_per_second", value)

    @property
    @pulumi.getter(name="scanSamplesPerSecond")
    def scan_samples_per_second(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        最大每秒扫描样本数。整数形式，默认取值范围为 1～1000000000。
        """
        return pulumi.get(self, "scan_samples_per_second")

    @scan_samples_per_second.setter
    def scan_samples_per_second(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "scan_samples_per_second", value)

    @property
    @pulumi.getter(name="scanSeriesPerSecond")
    def scan_series_per_second(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        最大每秒扫描时序数。整数形式，默认取值范围为 1～200000。
        """
        return pulumi.get(self, "scan_series_per_second")

    @scan_series_per_second.setter
    def scan_series_per_second(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "scan_series_per_second", value)


if not MYPY:
    class WorkspaceTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        标签键。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        标签值。
        """
elif False:
    WorkspaceTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class WorkspaceTagArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] key: 标签键。
        :param pulumi.Input[builtins.str] value: 标签值。
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        标签键。
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        标签值。
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "value", value)


if not MYPY:
    class WorkspaceUsageArgsDict(TypedDict):
        active_series: NotRequired[pulumi.Input[builtins.int]]
        """
        活跃时序数。
        """
        ingested_samples_per_second: NotRequired[pulumi.Input[builtins.float]]
        """
        每秒写入样本数。
        """
elif False:
    WorkspaceUsageArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class WorkspaceUsageArgs:
    def __init__(__self__, *,
                 active_series: Optional[pulumi.Input[builtins.int]] = None,
                 ingested_samples_per_second: Optional[pulumi.Input[builtins.float]] = None):
        """
        :param pulumi.Input[builtins.int] active_series: 活跃时序数。
        :param pulumi.Input[builtins.float] ingested_samples_per_second: 每秒写入样本数。
        """
        if active_series is not None:
            pulumi.set(__self__, "active_series", active_series)
        if ingested_samples_per_second is not None:
            pulumi.set(__self__, "ingested_samples_per_second", ingested_samples_per_second)

    @property
    @pulumi.getter(name="activeSeries")
    def active_series(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        活跃时序数。
        """
        return pulumi.get(self, "active_series")

    @active_series.setter
    def active_series(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "active_series", value)

    @property
    @pulumi.getter(name="ingestedSamplesPerSecond")
    def ingested_samples_per_second(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        每秒写入样本数。
        """
        return pulumi.get(self, "ingested_samples_per_second")

    @ingested_samples_per_second.setter
    def ingested_samples_per_second(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "ingested_samples_per_second", value)


