# 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
from . import outputs

__all__ = [
    'IndexFullText',
    'IndexKeyValue',
    'IndexKeyValueValue',
    'IndexKeyValueValueJsonKey',
    'IndexKeyValueValueJsonKeyValue',
    'IndexUserInnerKeyValue',
    'IndexUserInnerKeyValueValue',
    'IndexUserInnerKeyValueValueJsonKey',
    'IndexUserInnerKeyValueValueJsonKeyValue',
    'ProjectTag',
    'ScheduleSqlTaskRequestCycle',
    'TopicTag',
    'GetIndexFullTextResult',
    'GetIndexKeyValueResult',
    'GetIndexKeyValueValueResult',
    'GetIndexKeyValueValueJsonKeyResult',
    'GetIndexKeyValueValueJsonKeyValueResult',
    'GetIndexUserInnerKeyValueResult',
    'GetIndexUserInnerKeyValueValueResult',
    'GetIndexUserInnerKeyValueValueJsonKeyResult',
    'GetIndexUserInnerKeyValueValueJsonKeyValueResult',
    'GetProjectTagResult',
    'GetScheduleSqlTaskRequestCycleResult',
    'GetTopicTagResult',
]

@pulumi.output_type
class IndexFullText(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "caseSensitive":
            suggest = "case_sensitive"
        elif key == "includeChinese":
            suggest = "include_chinese"

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

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

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

    def __init__(__self__, *,
                 case_sensitive: Optional[builtins.bool] = None,
                 delimiter: Optional[builtins.str] = None,
                 include_chinese: Optional[builtins.bool] = None):
        """
        :param builtins.bool case_sensitive: 是否大小写敏感。true：大小写敏感。false：大小写不敏感。
        :param builtins.str delimiter: 全文索引的分词符。字符串中每个字符代表一个分词符。长度为 1~256 字节。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        :param builtins.bool include_chinese: 检索时，是否对日志的中文内容按照中文语法进行分词，默认为 false。true：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。false：按照分词符参数中指定的分词符对日志进行分词。
        """
        if case_sensitive is not None:
            pulumi.set(__self__, "case_sensitive", case_sensitive)
        if delimiter is not None:
            pulumi.set(__self__, "delimiter", delimiter)
        if include_chinese is not None:
            pulumi.set(__self__, "include_chinese", include_chinese)

    @property
    @pulumi.getter(name="caseSensitive")
    def case_sensitive(self) -> Optional[builtins.bool]:
        """
        是否大小写敏感。true：大小写敏感。false：大小写不敏感。
        """
        return pulumi.get(self, "case_sensitive")

    @property
    @pulumi.getter
    def delimiter(self) -> Optional[builtins.str]:
        """
        全文索引的分词符。字符串中每个字符代表一个分词符。长度为 1~256 字节。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        """
        return pulumi.get(self, "delimiter")

    @property
    @pulumi.getter(name="includeChinese")
    def include_chinese(self) -> Optional[builtins.bool]:
        """
        检索时，是否对日志的中文内容按照中文语法进行分词，默认为 false。true：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。false：按照分词符参数中指定的分词符对日志进行分词。
        """
        return pulumi.get(self, "include_chinese")


@pulumi.output_type
class IndexKeyValue(dict):
    def __init__(__self__, *,
                 key: Optional[builtins.str] = None,
                 value: Optional['outputs.IndexKeyValueValue'] = None):
        """
        :param builtins.str key: 需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        :param 'IndexKeyValueValueArgs' 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]:
        """
        需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional['outputs.IndexKeyValueValue']:
        """
        需要配置键值索引的字段描述信息。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class IndexKeyValueValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoIndexFlag":
            suggest = "auto_index_flag"
        elif key == "caseSensitive":
            suggest = "case_sensitive"
        elif key == "includeChinese":
            suggest = "include_chinese"
        elif key == "indexAll":
            suggest = "index_all"
        elif key == "indexSqlAll":
            suggest = "index_sql_all"
        elif key == "jsonKeys":
            suggest = "json_keys"
        elif key == "sqlFlag":
            suggest = "sql_flag"
        elif key == "valueType":
            suggest = "value_type"

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

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

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

    def __init__(__self__, *,
                 auto_index_flag: Optional[builtins.bool] = None,
                 case_sensitive: Optional[builtins.bool] = None,
                 delimiter: Optional[builtins.str] = None,
                 include_chinese: Optional[builtins.bool] = None,
                 index_all: Optional[builtins.bool] = None,
                 index_sql_all: Optional[builtins.bool] = None,
                 json_keys: Optional[Sequence['outputs.IndexKeyValueValueJsonKey']] = None,
                 sql_flag: Optional[builtins.bool] = None,
                 value_type: Optional[builtins.str] = None):
        """
        :param builtins.bool auto_index_flag: 该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        :param builtins.bool case_sensitive: 是否区分大小写。默认为 false。
        :param builtins.str delimiter: 字段的分词符。默认为空（""）。字符串中每个字符代表一个分词符。长度为 0~256 字节，长度为 0 时表示不分词。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        :param builtins.bool include_chinese: 检索时，是否对日志的中文内容按照中文语法进行分词。启用：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。未启用：按照分词符参数中指定的分词符对日志进行分词。
        :param builtins.bool index_all: 是否为 JSON 字段中所有值为文本的字段创建索引。
        :param builtins.bool index_sql_all: 是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        :param builtins.bool sql_flag: 字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        :param builtins.str value_type: 字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        if auto_index_flag is not None:
            pulumi.set(__self__, "auto_index_flag", auto_index_flag)
        if case_sensitive is not None:
            pulumi.set(__self__, "case_sensitive", case_sensitive)
        if delimiter is not None:
            pulumi.set(__self__, "delimiter", delimiter)
        if include_chinese is not None:
            pulumi.set(__self__, "include_chinese", include_chinese)
        if index_all is not None:
            pulumi.set(__self__, "index_all", index_all)
        if index_sql_all is not None:
            pulumi.set(__self__, "index_sql_all", index_sql_all)
        if json_keys is not None:
            pulumi.set(__self__, "json_keys", json_keys)
        if sql_flag is not None:
            pulumi.set(__self__, "sql_flag", sql_flag)
        if value_type is not None:
            pulumi.set(__self__, "value_type", value_type)

    @property
    @pulumi.getter(name="autoIndexFlag")
    def auto_index_flag(self) -> Optional[builtins.bool]:
        """
        该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        """
        return pulumi.get(self, "auto_index_flag")

    @property
    @pulumi.getter(name="caseSensitive")
    def case_sensitive(self) -> Optional[builtins.bool]:
        """
        是否区分大小写。默认为 false。
        """
        return pulumi.get(self, "case_sensitive")

    @property
    @pulumi.getter
    def delimiter(self) -> Optional[builtins.str]:
        """
        字段的分词符。默认为空（""）。字符串中每个字符代表一个分词符。长度为 0~256 字节，长度为 0 时表示不分词。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        """
        return pulumi.get(self, "delimiter")

    @property
    @pulumi.getter(name="includeChinese")
    def include_chinese(self) -> Optional[builtins.bool]:
        """
        检索时，是否对日志的中文内容按照中文语法进行分词。启用：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。未启用：按照分词符参数中指定的分词符对日志进行分词。
        """
        return pulumi.get(self, "include_chinese")

    @property
    @pulumi.getter(name="indexAll")
    def index_all(self) -> Optional[builtins.bool]:
        """
        是否为 JSON 字段中所有值为文本的字段创建索引。
        """
        return pulumi.get(self, "index_all")

    @property
    @pulumi.getter(name="indexSqlAll")
    def index_sql_all(self) -> Optional[builtins.bool]:
        """
        是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        """
        return pulumi.get(self, "index_sql_all")

    @property
    @pulumi.getter(name="jsonKeys")
    def json_keys(self) -> Optional[Sequence['outputs.IndexKeyValueValueJsonKey']]:
        return pulumi.get(self, "json_keys")

    @property
    @pulumi.getter(name="sqlFlag")
    def sql_flag(self) -> Optional[builtins.bool]:
        """
        字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        """
        return pulumi.get(self, "sql_flag")

    @property
    @pulumi.getter(name="valueType")
    def value_type(self) -> Optional[builtins.str]:
        """
        字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        return pulumi.get(self, "value_type")


@pulumi.output_type
class IndexKeyValueValueJsonKey(dict):
    def __init__(__self__, *,
                 key: Optional[builtins.str] = None,
                 value: Optional['outputs.IndexKeyValueValueJsonKeyValue'] = None):
        """
        :param builtins.str key: 需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        :param 'IndexKeyValueValueJsonKeyValueArgs' 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]:
        """
        需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional['outputs.IndexKeyValueValueJsonKeyValue']:
        """
        需要配置键值索引的字段描述信息。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class IndexKeyValueValueJsonKeyValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoIndexFlag":
            suggest = "auto_index_flag"
        elif key == "indexAll":
            suggest = "index_all"
        elif key == "indexSqlAll":
            suggest = "index_sql_all"
        elif key == "sqlFlag":
            suggest = "sql_flag"
        elif key == "valueType":
            suggest = "value_type"

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

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

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

    def __init__(__self__, *,
                 auto_index_flag: Optional[builtins.bool] = None,
                 index_all: Optional[builtins.bool] = None,
                 index_sql_all: Optional[builtins.bool] = None,
                 sql_flag: Optional[builtins.bool] = None,
                 value_type: Optional[builtins.str] = None):
        """
        :param builtins.bool auto_index_flag: 该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        :param builtins.bool index_all: 是否为 JSON 字段中所有值为文本的字段创建索引。
        :param builtins.bool index_sql_all: 是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        :param builtins.bool sql_flag: 字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        :param builtins.str value_type: 字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        if auto_index_flag is not None:
            pulumi.set(__self__, "auto_index_flag", auto_index_flag)
        if index_all is not None:
            pulumi.set(__self__, "index_all", index_all)
        if index_sql_all is not None:
            pulumi.set(__self__, "index_sql_all", index_sql_all)
        if sql_flag is not None:
            pulumi.set(__self__, "sql_flag", sql_flag)
        if value_type is not None:
            pulumi.set(__self__, "value_type", value_type)

    @property
    @pulumi.getter(name="autoIndexFlag")
    def auto_index_flag(self) -> Optional[builtins.bool]:
        """
        该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        """
        return pulumi.get(self, "auto_index_flag")

    @property
    @pulumi.getter(name="indexAll")
    def index_all(self) -> Optional[builtins.bool]:
        """
        是否为 JSON 字段中所有值为文本的字段创建索引。
        """
        return pulumi.get(self, "index_all")

    @property
    @pulumi.getter(name="indexSqlAll")
    def index_sql_all(self) -> Optional[builtins.bool]:
        """
        是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        """
        return pulumi.get(self, "index_sql_all")

    @property
    @pulumi.getter(name="sqlFlag")
    def sql_flag(self) -> Optional[builtins.bool]:
        """
        字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        """
        return pulumi.get(self, "sql_flag")

    @property
    @pulumi.getter(name="valueType")
    def value_type(self) -> Optional[builtins.str]:
        """
        字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        return pulumi.get(self, "value_type")


@pulumi.output_type
class IndexUserInnerKeyValue(dict):
    def __init__(__self__, *,
                 key: Optional[builtins.str] = None,
                 value: Optional['outputs.IndexUserInnerKeyValueValue'] = None):
        """
        :param builtins.str key: 需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        :param 'IndexUserInnerKeyValueValueArgs' 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]:
        """
        需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional['outputs.IndexUserInnerKeyValueValue']:
        """
        需要配置键值索引的字段描述信息。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class IndexUserInnerKeyValueValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoIndexFlag":
            suggest = "auto_index_flag"
        elif key == "caseSensitive":
            suggest = "case_sensitive"
        elif key == "includeChinese":
            suggest = "include_chinese"
        elif key == "indexAll":
            suggest = "index_all"
        elif key == "indexSqlAll":
            suggest = "index_sql_all"
        elif key == "jsonKeys":
            suggest = "json_keys"
        elif key == "sqlFlag":
            suggest = "sql_flag"
        elif key == "valueType":
            suggest = "value_type"

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

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

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

    def __init__(__self__, *,
                 auto_index_flag: Optional[builtins.bool] = None,
                 case_sensitive: Optional[builtins.bool] = None,
                 delimiter: Optional[builtins.str] = None,
                 include_chinese: Optional[builtins.bool] = None,
                 index_all: Optional[builtins.bool] = None,
                 index_sql_all: Optional[builtins.bool] = None,
                 json_keys: Optional[Sequence['outputs.IndexUserInnerKeyValueValueJsonKey']] = None,
                 sql_flag: Optional[builtins.bool] = None,
                 value_type: Optional[builtins.str] = None):
        """
        :param builtins.bool auto_index_flag: 该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        :param builtins.bool case_sensitive: 是否区分大小写。默认为 false。
        :param builtins.str delimiter: 字段的分词符。默认为空（""）。字符串中每个字符代表一个分词符。长度为 0~256 字节，长度为 0 时表示不分词。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        :param builtins.bool include_chinese: 检索时，是否对日志的中文内容按照中文语法进行分词。启用：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。未启用：按照分词符参数中指定的分词符对日志进行分词。
        :param builtins.bool index_all: 是否为 JSON 字段中所有值为文本的字段创建索引。
        :param builtins.bool index_sql_all: 是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        :param builtins.bool sql_flag: 字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        :param builtins.str value_type: 字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        if auto_index_flag is not None:
            pulumi.set(__self__, "auto_index_flag", auto_index_flag)
        if case_sensitive is not None:
            pulumi.set(__self__, "case_sensitive", case_sensitive)
        if delimiter is not None:
            pulumi.set(__self__, "delimiter", delimiter)
        if include_chinese is not None:
            pulumi.set(__self__, "include_chinese", include_chinese)
        if index_all is not None:
            pulumi.set(__self__, "index_all", index_all)
        if index_sql_all is not None:
            pulumi.set(__self__, "index_sql_all", index_sql_all)
        if json_keys is not None:
            pulumi.set(__self__, "json_keys", json_keys)
        if sql_flag is not None:
            pulumi.set(__self__, "sql_flag", sql_flag)
        if value_type is not None:
            pulumi.set(__self__, "value_type", value_type)

    @property
    @pulumi.getter(name="autoIndexFlag")
    def auto_index_flag(self) -> Optional[builtins.bool]:
        """
        该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        """
        return pulumi.get(self, "auto_index_flag")

    @property
    @pulumi.getter(name="caseSensitive")
    def case_sensitive(self) -> Optional[builtins.bool]:
        """
        是否区分大小写。默认为 false。
        """
        return pulumi.get(self, "case_sensitive")

    @property
    @pulumi.getter
    def delimiter(self) -> Optional[builtins.str]:
        """
        字段的分词符。默认为空（""）。字符串中每个字符代表一个分词符。长度为 0~256 字节，长度为 0 时表示不分词。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        """
        return pulumi.get(self, "delimiter")

    @property
    @pulumi.getter(name="includeChinese")
    def include_chinese(self) -> Optional[builtins.bool]:
        """
        检索时，是否对日志的中文内容按照中文语法进行分词。启用：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。未启用：按照分词符参数中指定的分词符对日志进行分词。
        """
        return pulumi.get(self, "include_chinese")

    @property
    @pulumi.getter(name="indexAll")
    def index_all(self) -> Optional[builtins.bool]:
        """
        是否为 JSON 字段中所有值为文本的字段创建索引。
        """
        return pulumi.get(self, "index_all")

    @property
    @pulumi.getter(name="indexSqlAll")
    def index_sql_all(self) -> Optional[builtins.bool]:
        """
        是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        """
        return pulumi.get(self, "index_sql_all")

    @property
    @pulumi.getter(name="jsonKeys")
    def json_keys(self) -> Optional[Sequence['outputs.IndexUserInnerKeyValueValueJsonKey']]:
        return pulumi.get(self, "json_keys")

    @property
    @pulumi.getter(name="sqlFlag")
    def sql_flag(self) -> Optional[builtins.bool]:
        """
        字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        """
        return pulumi.get(self, "sql_flag")

    @property
    @pulumi.getter(name="valueType")
    def value_type(self) -> Optional[builtins.str]:
        """
        字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        return pulumi.get(self, "value_type")


@pulumi.output_type
class IndexUserInnerKeyValueValueJsonKey(dict):
    def __init__(__self__, *,
                 key: Optional[builtins.str] = None,
                 value: Optional['outputs.IndexUserInnerKeyValueValueJsonKeyValue'] = None):
        """
        :param builtins.str key: 需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        :param 'IndexUserInnerKeyValueValueJsonKeyValueArgs' 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]:
        """
        需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional['outputs.IndexUserInnerKeyValueValueJsonKeyValue']:
        """
        需要配置键值索引的字段描述信息。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class IndexUserInnerKeyValueValueJsonKeyValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoIndexFlag":
            suggest = "auto_index_flag"
        elif key == "indexAll":
            suggest = "index_all"
        elif key == "indexSqlAll":
            suggest = "index_sql_all"
        elif key == "sqlFlag":
            suggest = "sql_flag"
        elif key == "valueType":
            suggest = "value_type"

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

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

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

    def __init__(__self__, *,
                 auto_index_flag: Optional[builtins.bool] = None,
                 index_all: Optional[builtins.bool] = None,
                 index_sql_all: Optional[builtins.bool] = None,
                 sql_flag: Optional[builtins.bool] = None,
                 value_type: Optional[builtins.str] = None):
        """
        :param builtins.bool auto_index_flag: 该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        :param builtins.bool index_all: 是否为 JSON 字段中所有值为文本的字段创建索引。
        :param builtins.bool index_sql_all: 是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        :param builtins.bool sql_flag: 字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        :param builtins.str value_type: 字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        if auto_index_flag is not None:
            pulumi.set(__self__, "auto_index_flag", auto_index_flag)
        if index_all is not None:
            pulumi.set(__self__, "index_all", index_all)
        if index_sql_all is not None:
            pulumi.set(__self__, "index_sql_all", index_sql_all)
        if sql_flag is not None:
            pulumi.set(__self__, "sql_flag", sql_flag)
        if value_type is not None:
            pulumi.set(__self__, "value_type", value_type)

    @property
    @pulumi.getter(name="autoIndexFlag")
    def auto_index_flag(self) -> Optional[builtins.bool]:
        """
        该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        """
        return pulumi.get(self, "auto_index_flag")

    @property
    @pulumi.getter(name="indexAll")
    def index_all(self) -> Optional[builtins.bool]:
        """
        是否为 JSON 字段中所有值为文本的字段创建索引。
        """
        return pulumi.get(self, "index_all")

    @property
    @pulumi.getter(name="indexSqlAll")
    def index_sql_all(self) -> Optional[builtins.bool]:
        """
        是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        """
        return pulumi.get(self, "index_sql_all")

    @property
    @pulumi.getter(name="sqlFlag")
    def sql_flag(self) -> Optional[builtins.bool]:
        """
        字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        """
        return pulumi.get(self, "sql_flag")

    @property
    @pulumi.getter(name="valueType")
    def value_type(self) -> Optional[builtins.str]:
        """
        字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        return pulumi.get(self, "value_type")


@pulumi.output_type
class ProjectTag(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 ScheduleSqlTaskRequestCycle(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cronTab":
            suggest = "cron_tab"
        elif key == "cronTimeZone":
            suggest = "cron_time_zone"

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

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

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

    def __init__(__self__, *,
                 time: builtins.int,
                 type: builtins.str,
                 cron_tab: Optional[builtins.str] = None,
                 cron_time_zone: Optional[builtins.str] = None):
        """
        :param builtins.int time: 调度的周期或者定期执行的时间点（距离 00:00 的分钟数），取值范围为 1~1440，单位为分钟。
        :param builtins.str type: 调度周期类型。可选值：Period、Fixed、Cron。
        :param builtins.str cron_tab: Cron 表达式，最小粒度为分钟，24 小时制。例如 0 18 * * * 表示每天 18 点整执行一次。
        :param builtins.str cron_time_zone: 设置 Type 为 Cron 时，还需设置时区。
        """
        pulumi.set(__self__, "time", time)
        pulumi.set(__self__, "type", type)
        if cron_tab is not None:
            pulumi.set(__self__, "cron_tab", cron_tab)
        if cron_time_zone is not None:
            pulumi.set(__self__, "cron_time_zone", cron_time_zone)

    @property
    @pulumi.getter
    def time(self) -> builtins.int:
        """
        调度的周期或者定期执行的时间点（距离 00:00 的分钟数），取值范围为 1~1440，单位为分钟。
        """
        return pulumi.get(self, "time")

    @property
    @pulumi.getter
    def type(self) -> builtins.str:
        """
        调度周期类型。可选值：Period、Fixed、Cron。
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="cronTab")
    def cron_tab(self) -> Optional[builtins.str]:
        """
        Cron 表达式，最小粒度为分钟，24 小时制。例如 0 18 * * * 表示每天 18 点整执行一次。
        """
        return pulumi.get(self, "cron_tab")

    @property
    @pulumi.getter(name="cronTimeZone")
    def cron_time_zone(self) -> Optional[builtins.str]:
        """
        设置 Type 为 Cron 时，还需设置时区。
        """
        return pulumi.get(self, "cron_time_zone")


@pulumi.output_type
class TopicTag(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 GetIndexFullTextResult(dict):
    def __init__(__self__, *,
                 case_sensitive: builtins.bool,
                 delimiter: builtins.str,
                 include_chinese: builtins.bool):
        """
        :param builtins.bool case_sensitive: 是否大小写敏感。true：大小写敏感。false：大小写不敏感。
        :param builtins.str delimiter: 全文索引的分词符。字符串中每个字符代表一个分词符。长度为 1~256 字节。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        :param builtins.bool include_chinese: 检索时，是否对日志的中文内容按照中文语法进行分词，默认为 false。true：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。false：按照分词符参数中指定的分词符对日志进行分词。
        """
        pulumi.set(__self__, "case_sensitive", case_sensitive)
        pulumi.set(__self__, "delimiter", delimiter)
        pulumi.set(__self__, "include_chinese", include_chinese)

    @property
    @pulumi.getter(name="caseSensitive")
    def case_sensitive(self) -> builtins.bool:
        """
        是否大小写敏感。true：大小写敏感。false：大小写不敏感。
        """
        return pulumi.get(self, "case_sensitive")

    @property
    @pulumi.getter
    def delimiter(self) -> builtins.str:
        """
        全文索引的分词符。字符串中每个字符代表一个分词符。长度为 1~256 字节。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        """
        return pulumi.get(self, "delimiter")

    @property
    @pulumi.getter(name="includeChinese")
    def include_chinese(self) -> builtins.bool:
        """
        检索时，是否对日志的中文内容按照中文语法进行分词，默认为 false。true：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。false：按照分词符参数中指定的分词符对日志进行分词。
        """
        return pulumi.get(self, "include_chinese")


@pulumi.output_type
class GetIndexKeyValueResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 value: 'outputs.GetIndexKeyValueValueResult'):
        """
        :param builtins.str key: 需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        :param 'GetIndexKeyValueValueArgs' value: 需要配置键值索引的字段描述信息。
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> 'outputs.GetIndexKeyValueValueResult':
        """
        需要配置键值索引的字段描述信息。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetIndexKeyValueValueResult(dict):
    def __init__(__self__, *,
                 auto_index_flag: builtins.bool,
                 case_sensitive: builtins.bool,
                 delimiter: builtins.str,
                 include_chinese: builtins.bool,
                 index_all: builtins.bool,
                 index_sql_all: builtins.bool,
                 json_keys: Sequence['outputs.GetIndexKeyValueValueJsonKeyResult'],
                 sql_flag: builtins.bool,
                 value_type: builtins.str):
        """
        :param builtins.bool auto_index_flag: 该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        :param builtins.bool case_sensitive: 是否区分大小写。默认为 false。
        :param builtins.str delimiter: 字段的分词符。默认为空（""）。字符串中每个字符代表一个分词符。长度为 0~256 字节，长度为 0 时表示不分词。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        :param builtins.bool include_chinese: 检索时，是否对日志的中文内容按照中文语法进行分词。启用：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。未启用：按照分词符参数中指定的分词符对日志进行分词。
        :param builtins.bool index_all: 是否为 JSON 字段中所有值为文本的字段创建索引。
        :param builtins.bool index_sql_all: 是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        :param Sequence['GetIndexKeyValueValueJsonKeyArgs'] json_keys: 当 ValueType 为 json 时，可通过 JsonKeys 字段配置 JSON 子字段键值索引，其值为 KeyValueInfo 数组。JsonKeys 列表中每个元素为 KeyValueInfo，可进一步嵌套定义 text、long、double 类型子字段。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。JsonKeys 中定义的子字段键值索引的 SqlFlag 设置应与其父字段设置保持一致，即需要同时开启或关闭，默认为关闭状态。子字段不支持单独设置 Delimiter、CaseSensitive 和 IncludeChinese，对于 text 类型的字段，CaseSensitive、Delimiter 和 IncludeChinese 固定沿用父字段设置。仅当 ValueType 为 json 时设置。
        :param builtins.bool sql_flag: 字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        :param builtins.str value_type: 字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        pulumi.set(__self__, "auto_index_flag", auto_index_flag)
        pulumi.set(__self__, "case_sensitive", case_sensitive)
        pulumi.set(__self__, "delimiter", delimiter)
        pulumi.set(__self__, "include_chinese", include_chinese)
        pulumi.set(__self__, "index_all", index_all)
        pulumi.set(__self__, "index_sql_all", index_sql_all)
        pulumi.set(__self__, "json_keys", json_keys)
        pulumi.set(__self__, "sql_flag", sql_flag)
        pulumi.set(__self__, "value_type", value_type)

    @property
    @pulumi.getter(name="autoIndexFlag")
    def auto_index_flag(self) -> builtins.bool:
        """
        该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        """
        return pulumi.get(self, "auto_index_flag")

    @property
    @pulumi.getter(name="caseSensitive")
    def case_sensitive(self) -> builtins.bool:
        """
        是否区分大小写。默认为 false。
        """
        return pulumi.get(self, "case_sensitive")

    @property
    @pulumi.getter
    def delimiter(self) -> builtins.str:
        """
        字段的分词符。默认为空（""）。字符串中每个字符代表一个分词符。长度为 0~256 字节，长度为 0 时表示不分词。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        """
        return pulumi.get(self, "delimiter")

    @property
    @pulumi.getter(name="includeChinese")
    def include_chinese(self) -> builtins.bool:
        """
        检索时，是否对日志的中文内容按照中文语法进行分词。启用：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。未启用：按照分词符参数中指定的分词符对日志进行分词。
        """
        return pulumi.get(self, "include_chinese")

    @property
    @pulumi.getter(name="indexAll")
    def index_all(self) -> builtins.bool:
        """
        是否为 JSON 字段中所有值为文本的字段创建索引。
        """
        return pulumi.get(self, "index_all")

    @property
    @pulumi.getter(name="indexSqlAll")
    def index_sql_all(self) -> builtins.bool:
        """
        是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        """
        return pulumi.get(self, "index_sql_all")

    @property
    @pulumi.getter(name="jsonKeys")
    def json_keys(self) -> Sequence['outputs.GetIndexKeyValueValueJsonKeyResult']:
        """
        当 ValueType 为 json 时，可通过 JsonKeys 字段配置 JSON 子字段键值索引，其值为 KeyValueInfo 数组。JsonKeys 列表中每个元素为 KeyValueInfo，可进一步嵌套定义 text、long、double 类型子字段。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。JsonKeys 中定义的子字段键值索引的 SqlFlag 设置应与其父字段设置保持一致，即需要同时开启或关闭，默认为关闭状态。子字段不支持单独设置 Delimiter、CaseSensitive 和 IncludeChinese，对于 text 类型的字段，CaseSensitive、Delimiter 和 IncludeChinese 固定沿用父字段设置。仅当 ValueType 为 json 时设置。
        """
        return pulumi.get(self, "json_keys")

    @property
    @pulumi.getter(name="sqlFlag")
    def sql_flag(self) -> builtins.bool:
        """
        字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        """
        return pulumi.get(self, "sql_flag")

    @property
    @pulumi.getter(name="valueType")
    def value_type(self) -> builtins.str:
        """
        字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        return pulumi.get(self, "value_type")


@pulumi.output_type
class GetIndexKeyValueValueJsonKeyResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 value: 'outputs.GetIndexKeyValueValueJsonKeyValueResult'):
        """
        :param builtins.str key: 需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        :param 'GetIndexKeyValueValueJsonKeyValueArgs' value: 需要配置键值索引的字段描述信息。
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> 'outputs.GetIndexKeyValueValueJsonKeyValueResult':
        """
        需要配置键值索引的字段描述信息。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetIndexKeyValueValueJsonKeyValueResult(dict):
    def __init__(__self__, *,
                 auto_index_flag: builtins.bool,
                 case_sensitive: builtins.bool,
                 delimiter: builtins.str,
                 include_chinese: builtins.bool,
                 index_all: builtins.bool,
                 index_sql_all: builtins.bool,
                 sql_flag: builtins.bool,
                 value_type: builtins.str):
        """
        :param builtins.bool auto_index_flag: 该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        :param builtins.bool case_sensitive: 是否区分大小写。默认为 false。
        :param builtins.str delimiter: 字段的分词符。默认为空（""）。字符串中每个字符代表一个分词符。长度为 0~256 字节，长度为 0 时表示不分词。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        :param builtins.bool include_chinese: 检索时，是否对日志的中文内容按照中文语法进行分词。启用：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。未启用：按照分词符参数中指定的分词符对日志进行分词。
        :param builtins.bool index_all: 是否为 JSON 字段中所有值为文本的字段创建索引。
        :param builtins.bool index_sql_all: 是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        :param builtins.bool sql_flag: 字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        :param builtins.str value_type: 字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        pulumi.set(__self__, "auto_index_flag", auto_index_flag)
        pulumi.set(__self__, "case_sensitive", case_sensitive)
        pulumi.set(__self__, "delimiter", delimiter)
        pulumi.set(__self__, "include_chinese", include_chinese)
        pulumi.set(__self__, "index_all", index_all)
        pulumi.set(__self__, "index_sql_all", index_sql_all)
        pulumi.set(__self__, "sql_flag", sql_flag)
        pulumi.set(__self__, "value_type", value_type)

    @property
    @pulumi.getter(name="autoIndexFlag")
    def auto_index_flag(self) -> builtins.bool:
        """
        该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        """
        return pulumi.get(self, "auto_index_flag")

    @property
    @pulumi.getter(name="caseSensitive")
    def case_sensitive(self) -> builtins.bool:
        """
        是否区分大小写。默认为 false。
        """
        return pulumi.get(self, "case_sensitive")

    @property
    @pulumi.getter
    def delimiter(self) -> builtins.str:
        """
        字段的分词符。默认为空（""）。字符串中每个字符代表一个分词符。长度为 0~256 字节，长度为 0 时表示不分词。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        """
        return pulumi.get(self, "delimiter")

    @property
    @pulumi.getter(name="includeChinese")
    def include_chinese(self) -> builtins.bool:
        """
        检索时，是否对日志的中文内容按照中文语法进行分词。启用：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。未启用：按照分词符参数中指定的分词符对日志进行分词。
        """
        return pulumi.get(self, "include_chinese")

    @property
    @pulumi.getter(name="indexAll")
    def index_all(self) -> builtins.bool:
        """
        是否为 JSON 字段中所有值为文本的字段创建索引。
        """
        return pulumi.get(self, "index_all")

    @property
    @pulumi.getter(name="indexSqlAll")
    def index_sql_all(self) -> builtins.bool:
        """
        是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        """
        return pulumi.get(self, "index_sql_all")

    @property
    @pulumi.getter(name="sqlFlag")
    def sql_flag(self) -> builtins.bool:
        """
        字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        """
        return pulumi.get(self, "sql_flag")

    @property
    @pulumi.getter(name="valueType")
    def value_type(self) -> builtins.str:
        """
        字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        return pulumi.get(self, "value_type")


@pulumi.output_type
class GetIndexUserInnerKeyValueResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 value: 'outputs.GetIndexUserInnerKeyValueValueResult'):
        """
        :param builtins.str key: 需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        :param 'GetIndexUserInnerKeyValueValueArgs' value: 需要配置键值索引的字段描述信息。
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> 'outputs.GetIndexUserInnerKeyValueValueResult':
        """
        需要配置键值索引的字段描述信息。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetIndexUserInnerKeyValueValueResult(dict):
    def __init__(__self__, *,
                 auto_index_flag: builtins.bool,
                 case_sensitive: builtins.bool,
                 delimiter: builtins.str,
                 include_chinese: builtins.bool,
                 index_all: builtins.bool,
                 index_sql_all: builtins.bool,
                 json_keys: Sequence['outputs.GetIndexUserInnerKeyValueValueJsonKeyResult'],
                 sql_flag: builtins.bool,
                 value_type: builtins.str):
        """
        :param builtins.bool auto_index_flag: 该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        :param builtins.bool case_sensitive: 是否区分大小写。默认为 false。
        :param builtins.str delimiter: 字段的分词符。默认为空（""）。字符串中每个字符代表一个分词符。长度为 0~256 字节，长度为 0 时表示不分词。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        :param builtins.bool include_chinese: 检索时，是否对日志的中文内容按照中文语法进行分词。启用：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。未启用：按照分词符参数中指定的分词符对日志进行分词。
        :param builtins.bool index_all: 是否为 JSON 字段中所有值为文本的字段创建索引。
        :param builtins.bool index_sql_all: 是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        :param Sequence['GetIndexUserInnerKeyValueValueJsonKeyArgs'] json_keys: 当 ValueType 为 json 时，可通过 JsonKeys 字段配置 JSON 子字段键值索引，其值为 KeyValueInfo 数组。JsonKeys 列表中每个元素为 KeyValueInfo，可进一步嵌套定义 text、long、double 类型子字段。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。JsonKeys 中定义的子字段键值索引的 SqlFlag 设置应与其父字段设置保持一致，即需要同时开启或关闭，默认为关闭状态。子字段不支持单独设置 Delimiter、CaseSensitive 和 IncludeChinese，对于 text 类型的字段，CaseSensitive、Delimiter 和 IncludeChinese 固定沿用父字段设置。仅当 ValueType 为 json 时设置。
        :param builtins.bool sql_flag: 字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        :param builtins.str value_type: 字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        pulumi.set(__self__, "auto_index_flag", auto_index_flag)
        pulumi.set(__self__, "case_sensitive", case_sensitive)
        pulumi.set(__self__, "delimiter", delimiter)
        pulumi.set(__self__, "include_chinese", include_chinese)
        pulumi.set(__self__, "index_all", index_all)
        pulumi.set(__self__, "index_sql_all", index_sql_all)
        pulumi.set(__self__, "json_keys", json_keys)
        pulumi.set(__self__, "sql_flag", sql_flag)
        pulumi.set(__self__, "value_type", value_type)

    @property
    @pulumi.getter(name="autoIndexFlag")
    def auto_index_flag(self) -> builtins.bool:
        """
        该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        """
        return pulumi.get(self, "auto_index_flag")

    @property
    @pulumi.getter(name="caseSensitive")
    def case_sensitive(self) -> builtins.bool:
        """
        是否区分大小写。默认为 false。
        """
        return pulumi.get(self, "case_sensitive")

    @property
    @pulumi.getter
    def delimiter(self) -> builtins.str:
        """
        字段的分词符。默认为空（""）。字符串中每个字符代表一个分词符。长度为 0~256 字节，长度为 0 时表示不分词。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        """
        return pulumi.get(self, "delimiter")

    @property
    @pulumi.getter(name="includeChinese")
    def include_chinese(self) -> builtins.bool:
        """
        检索时，是否对日志的中文内容按照中文语法进行分词。启用：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。未启用：按照分词符参数中指定的分词符对日志进行分词。
        """
        return pulumi.get(self, "include_chinese")

    @property
    @pulumi.getter(name="indexAll")
    def index_all(self) -> builtins.bool:
        """
        是否为 JSON 字段中所有值为文本的字段创建索引。
        """
        return pulumi.get(self, "index_all")

    @property
    @pulumi.getter(name="indexSqlAll")
    def index_sql_all(self) -> builtins.bool:
        """
        是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        """
        return pulumi.get(self, "index_sql_all")

    @property
    @pulumi.getter(name="jsonKeys")
    def json_keys(self) -> Sequence['outputs.GetIndexUserInnerKeyValueValueJsonKeyResult']:
        """
        当 ValueType 为 json 时，可通过 JsonKeys 字段配置 JSON 子字段键值索引，其值为 KeyValueInfo 数组。JsonKeys 列表中每个元素为 KeyValueInfo，可进一步嵌套定义 text、long、double 类型子字段。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。JsonKeys 中定义的子字段键值索引的 SqlFlag 设置应与其父字段设置保持一致，即需要同时开启或关闭，默认为关闭状态。子字段不支持单独设置 Delimiter、CaseSensitive 和 IncludeChinese，对于 text 类型的字段，CaseSensitive、Delimiter 和 IncludeChinese 固定沿用父字段设置。仅当 ValueType 为 json 时设置。
        """
        return pulumi.get(self, "json_keys")

    @property
    @pulumi.getter(name="sqlFlag")
    def sql_flag(self) -> builtins.bool:
        """
        字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        """
        return pulumi.get(self, "sql_flag")

    @property
    @pulumi.getter(name="valueType")
    def value_type(self) -> builtins.str:
        """
        字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        return pulumi.get(self, "value_type")


@pulumi.output_type
class GetIndexUserInnerKeyValueValueJsonKeyResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 value: 'outputs.GetIndexUserInnerKeyValueValueJsonKeyValueResult'):
        """
        :param builtins.str key: 需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        :param 'GetIndexUserInnerKeyValueValueJsonKeyValueArgs' value: 需要配置键值索引的字段描述信息。
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        需要配置键值索引的字段名称，最多添加 100 个字段。仅支持字母、数字、空格、下划线（_）、连字符（-）和斜线（/），并且不支持以空格开头或结尾。同一个索引中 key 名称唯一。长度为 1~128 字符。对于 JSON 类型键值索引的子字段，需要通过.表示 JSON 字段之间的层级关系，例如 JSON 字段 namelist 中包含 text 类型的子字段 totalcount 和 JSON 类型的 info，info 中又包含字段 name，各个字段名称应分别配置为totalcount 和 info.name。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> 'outputs.GetIndexUserInnerKeyValueValueJsonKeyValueResult':
        """
        需要配置键值索引的字段描述信息。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetIndexUserInnerKeyValueValueJsonKeyValueResult(dict):
    def __init__(__self__, *,
                 auto_index_flag: builtins.bool,
                 case_sensitive: builtins.bool,
                 delimiter: builtins.str,
                 include_chinese: builtins.bool,
                 index_all: builtins.bool,
                 index_sql_all: builtins.bool,
                 sql_flag: builtins.bool,
                 value_type: builtins.str):
        """
        :param builtins.bool auto_index_flag: 该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        :param builtins.bool case_sensitive: 是否区分大小写。默认为 false。
        :param builtins.str delimiter: 字段的分词符。默认为空（""）。字符串中每个字符代表一个分词符。长度为 0~256 字节，长度为 0 时表示不分词。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        :param builtins.bool include_chinese: 检索时，是否对日志的中文内容按照中文语法进行分词。启用：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。未启用：按照分词符参数中指定的分词符对日志进行分词。
        :param builtins.bool index_all: 是否为 JSON 字段中所有值为文本的字段创建索引。
        :param builtins.bool index_sql_all: 是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        :param builtins.bool sql_flag: 字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        :param builtins.str value_type: 字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        pulumi.set(__self__, "auto_index_flag", auto_index_flag)
        pulumi.set(__self__, "case_sensitive", case_sensitive)
        pulumi.set(__self__, "delimiter", delimiter)
        pulumi.set(__self__, "include_chinese", include_chinese)
        pulumi.set(__self__, "index_all", index_all)
        pulumi.set(__self__, "index_sql_all", index_sql_all)
        pulumi.set(__self__, "sql_flag", sql_flag)
        pulumi.set(__self__, "value_type", value_type)

    @property
    @pulumi.getter(name="autoIndexFlag")
    def auto_index_flag(self) -> builtins.bool:
        """
        该索引是否是自动索引添加。true：该索引为自动添加。false：该索引非自动添加。
        """
        return pulumi.get(self, "auto_index_flag")

    @property
    @pulumi.getter(name="caseSensitive")
    def case_sensitive(self) -> builtins.bool:
        """
        是否区分大小写。默认为 false。
        """
        return pulumi.get(self, "case_sensitive")

    @property
    @pulumi.getter
    def delimiter(self) -> builtins.str:
        """
        字段的分词符。默认为空（""）。字符串中每个字符代表一个分词符。长度为 0~256 字节，长度为 0 时表示不分词。仅支持以下字符中的一种或者多种：大小写字母、数字以及 !@#%^&*()-_=\\\\"', <>/?|;:\\	\\r[]{}.。支持同时配置包含中文和分词符。
        """
        return pulumi.get(self, "delimiter")

    @property
    @pulumi.getter(name="includeChinese")
    def include_chinese(self) -> builtins.bool:
        """
        检索时，是否对日志的中文内容按照中文语法进行分词。启用：日志内的中文字符：根据常见的中文语法对日志进行分词，不支持自定义中文内容的分词符。日志内的非中文字符：按照分词符参数中指定的分词符对日志进行分词。未启用：按照分词符参数中指定的分词符对日志进行分词。
        """
        return pulumi.get(self, "include_chinese")

    @property
    @pulumi.getter(name="indexAll")
    def index_all(self) -> builtins.bool:
        """
        是否为 JSON 字段中所有值为文本的字段创建索引。
        """
        return pulumi.get(self, "index_all")

    @property
    @pulumi.getter(name="indexSqlAll")
    def index_sql_all(self) -> builtins.bool:
        """
        是否为 JSON 字段开启自动索引和统计功能。true：开启自动索引和统计功能。false：不开启自动索引和统计功能。
        """
        return pulumi.get(self, "index_sql_all")

    @property
    @pulumi.getter(name="sqlFlag")
    def sql_flag(self) -> builtins.bool:
        """
        字段是否开启分析功能。默认为 false。开启统计分析功能后，支持配置分词符和包含中文。
        """
        return pulumi.get(self, "sql_flag")

    @property
    @pulumi.getter(name="valueType")
    def value_type(self) -> builtins.str:
        """
        字段类型。目前支持 long、double、text 和 json。long 和 double 类型不支持配置分词符、包含中文、大小写敏感。仅 json 类型支持进一步配置 JsonKeys 子字段。
        """
        return pulumi.get(self, "value_type")


@pulumi.output_type
class GetProjectTagResult(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 GetScheduleSqlTaskRequestCycleResult(dict):
    def __init__(__self__, *,
                 cron_tab: builtins.str,
                 cron_time_zone: builtins.str,
                 time: builtins.int,
                 type: builtins.str):
        """
        :param builtins.str cron_tab: Cron 表达式，最小粒度为分钟，24 小时制。例如 0 18 * * * 表示每天 18 点整执行一次。
        :param builtins.str cron_time_zone: 设置 Type 为 Cron 时，还需设置时区。
        :param builtins.int time: 调度的周期或者定期执行的时间点（距离 00:00 的分钟数），取值范围为 1~1440，单位为分钟。
        :param builtins.str type: 调度周期类型。可选值：Period、Fixed、Cron。
        """
        pulumi.set(__self__, "cron_tab", cron_tab)
        pulumi.set(__self__, "cron_time_zone", cron_time_zone)
        pulumi.set(__self__, "time", time)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="cronTab")
    def cron_tab(self) -> builtins.str:
        """
        Cron 表达式，最小粒度为分钟，24 小时制。例如 0 18 * * * 表示每天 18 点整执行一次。
        """
        return pulumi.get(self, "cron_tab")

    @property
    @pulumi.getter(name="cronTimeZone")
    def cron_time_zone(self) -> builtins.str:
        """
        设置 Type 为 Cron 时，还需设置时区。
        """
        return pulumi.get(self, "cron_time_zone")

    @property
    @pulumi.getter
    def time(self) -> builtins.int:
        """
        调度的周期或者定期执行的时间点（距离 00:00 的分钟数），取值范围为 1~1440，单位为分钟。
        """
        return pulumi.get(self, "time")

    @property
    @pulumi.getter
    def type(self) -> builtins.str:
        """
        调度周期类型。可选值：Period、Fixed、Cron。
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetTopicTagResult(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")


