# 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__ = [
    'WorkspaceInstanceType',
    'WorkspaceQuota',
    'WorkspaceTag',
    'WorkspaceUsage',
    'GetWorkspaceInstanceTypeResult',
    'GetWorkspaceQuotaResult',
    'GetWorkspaceTagResult',
    'GetWorkspaceUsageResult',
]

@pulumi.output_type
class WorkspaceInstanceType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "activeSeries":
            suggest = "active_series"
        elif key == "availabilityZoneReplicas":
            suggest = "availability_zone_replicas"
        elif key == "downsamplingPeriods":
            suggest = "downsampling_periods"
        elif key == "ingestSamplesPerSecond":
            suggest = "ingest_samples_per_second"
        elif key == "queryConcurrency":
            suggest = "query_concurrency"
        elif key == "queryPerSecond":
            suggest = "query_per_second"
        elif key == "replicasPerZone":
            suggest = "replicas_per_zone"
        elif key == "retentionPeriod":
            suggest = "retention_period"
        elif key == "scanSamplesPerSecond":
            suggest = "scan_samples_per_second"
        elif key == "scanSeriesPerSecond":
            suggest = "scan_series_per_second"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WorkspaceInstanceType. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WorkspaceInstanceType.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WorkspaceInstanceType.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 active_series: Optional[builtins.int] = None,
                 availability_zone_replicas: Optional[builtins.int] = None,
                 downsampling_periods: Optional[Sequence[builtins.str]] = None,
                 ingest_samples_per_second: Optional[builtins.int] = None,
                 query_concurrency: Optional[builtins.int] = None,
                 query_per_second: Optional[builtins.int] = None,
                 replicas_per_zone: Optional[builtins.int] = None,
                 retention_period: Optional[builtins.str] = None,
                 scan_samples_per_second: Optional[builtins.int] = None,
                 scan_series_per_second: Optional[builtins.int] = None):
        """
        :param builtins.int active_series: 最大活跃时序数。
        :param builtins.int availability_zone_replicas: 可用区（az）数。
        :param Sequence[builtins.str] downsampling_periods: 降采样策略。
        :param builtins.int ingest_samples_per_second: 最大每秒写入样本数。
        :param builtins.int query_concurrency: 最大查询并发数。
        :param builtins.int query_per_second: 最大查询 QPS。
        :param builtins.int replicas_per_zone: 每个可用区（az）的数据副本数。
        :param builtins.str retention_period: 最长数据保留时间。
        :param builtins.int scan_samples_per_second: 最大每秒扫描样本数。
        :param 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[builtins.int]:
        """
        最大活跃时序数。
        """
        return pulumi.get(self, "active_series")

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class WorkspaceQuota(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "activeSeries":
            suggest = "active_series"
        elif key == "ingestSamplesPerSecond":
            suggest = "ingest_samples_per_second"
        elif key == "queryPerSecond":
            suggest = "query_per_second"
        elif key == "scanSamplesPerSecond":
            suggest = "scan_samples_per_second"
        elif key == "scanSeriesPerSecond":
            suggest = "scan_series_per_second"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WorkspaceQuota. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WorkspaceQuota.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WorkspaceQuota.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 active_series: Optional[builtins.int] = None,
                 ingest_samples_per_second: Optional[builtins.int] = None,
                 query_per_second: Optional[builtins.int] = None,
                 scan_samples_per_second: Optional[builtins.int] = None,
                 scan_series_per_second: Optional[builtins.int] = None):
        """
        :param builtins.int active_series: 最大活跃时序数。整数形式，默认取值范围为 1～50000000。
        :param builtins.int ingest_samples_per_second: 指标摄入速率，即最大每秒写入样本数。整数形式，默认取值范围为 1～5000000。
        :param builtins.int query_per_second: 最大查询 QPS。整数形式，默认取值范围为 1～500。
        :param builtins.int scan_samples_per_second: 最大每秒扫描样本数。整数形式，默认取值范围为 1～1000000000。
        :param 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[builtins.int]:
        """
        最大活跃时序数。整数形式，默认取值范围为 1～50000000。
        """
        return pulumi.get(self, "active_series")

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

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

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

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


@pulumi.output_type
class WorkspaceTag(dict):
    def __init__(__self__, *,
                 key: Optional[builtins.str] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str key: 标签键。
        :param 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[builtins.str]:
        """
        标签键。
        """
        return pulumi.get(self, "key")

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


@pulumi.output_type
class WorkspaceUsage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "activeSeries":
            suggest = "active_series"
        elif key == "ingestedSamplesPerSecond":
            suggest = "ingested_samples_per_second"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WorkspaceUsage. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WorkspaceUsage.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WorkspaceUsage.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 active_series: Optional[builtins.int] = None,
                 ingested_samples_per_second: Optional[builtins.float] = None):
        """
        :param builtins.int active_series: 活跃时序数。
        :param 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[builtins.int]:
        """
        活跃时序数。
        """
        return pulumi.get(self, "active_series")

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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


@pulumi.output_type
class GetWorkspaceTagResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 value: builtins.str):
        """
        :param builtins.str key: 标签键。
        :param builtins.str value: 标签值。
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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


@pulumi.output_type
class GetWorkspaceUsageResult(dict):
    def __init__(__self__, *,
                 active_series: builtins.int,
                 ingested_samples_per_second: builtins.float):
        """
        :param builtins.int active_series: 活跃时序数。
        :param builtins.float ingested_samples_per_second: 每秒写入样本数。
        """
        pulumi.set(__self__, "active_series", active_series)
        pulumi.set(__self__, "ingested_samples_per_second", ingested_samples_per_second)

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

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


