pulumi-alicloud 3.60.0__py3-none-any.whl → 3.60.0a1720848019__py3-none-any.whl

pulumi_alicloud/oss/outputs.py

@@ -425,10 +425,6 @@ class BucketLifecycleRuleAbortMultipartUpload(dict):
     def __init__(__self__, *,
                  created_before_date: Optional[str] = None,
                  days: Optional[int] = None):
-        """
-        :param str created_before_date: Specifies the time before which the rules take effect. The date must conform to the ISO8601 format and always be UTC 00:00. For example: 2002-10-11T00:00:00.000Z indicates that parts created before 2002-10-11T00:00:00.000Z are deleted, and parts created after this time (including this time) are not deleted.
-        :param int days: Specifies the number of days noncurrent object versions transition.
-        """
         if created_before_date is not None:
             pulumi.set(__self__, "created_before_date", created_before_date)
         if days is not None:
@@ -437,17 +433,11 @@ class BucketLifecycleRuleAbortMultipartUpload(dict):
     @property
     @pulumi.getter(name="createdBeforeDate")
     def created_before_date(self) -> Optional[str]:
-        """
-        Specifies the time before which the rules take effect. The date must conform to the ISO8601 format and always be UTC 00:00. For example: 2002-10-11T00:00:00.000Z indicates that parts created before 2002-10-11T00:00:00.000Z are deleted, and parts created after this time (including this time) are not deleted.
-        """
         return pulumi.get(self, "created_before_date")
 
     @property
     @pulumi.getter
     def days(self) -> Optional[int]:
-        """
-        Specifies the number of days noncurrent object versions transition.
-        """
         return pulumi.get(self, "days")
 
 
@@ -477,14 +467,6 @@ class BucketLifecycleRuleExpiration(dict):
                  date: Optional[str] = None,
                  days: Optional[int] = None,
                  expired_object_delete_marker: Optional[bool] = None):
-        """
-        :param str created_before_date: Specifies the time before which the rules take effect. The date must conform to the ISO8601 format and always be UTC 00:00. For example: 2002-10-11T00:00:00.000Z indicates that parts created before 2002-10-11T00:00:00.000Z are deleted, and parts created after this time (including this time) are not deleted.
-        :param str date: Specifies the date after which you want the corresponding action to take effect. The value obeys ISO8601 format like `2017-03-09`.
-        :param int days: Specifies the number of days noncurrent object versions transition.
-        :param bool expired_object_delete_marker: On a versioned bucket (versioning-enabled or versioning-suspended bucket), you can add this element in the lifecycle configuration to direct OSS to delete expired object delete markers. This cannot be specified with Days, Date or CreatedBeforeDate in a Lifecycle Expiration Policy.
-               
-               `NOTE`: One and only one of "date", "days", "created_before_date" and "expired_object_delete_marker" can be specified in one expiration configuration.
-        """
         if created_before_date is not None:
             pulumi.set(__self__, "created_before_date", created_before_date)
         if date is not None:
@@ -497,35 +479,21 @@ class BucketLifecycleRuleExpiration(dict):
     @property
     @pulumi.getter(name="createdBeforeDate")
     def created_before_date(self) -> Optional[str]:
-        """
-        Specifies the time before which the rules take effect. The date must conform to the ISO8601 format and always be UTC 00:00. For example: 2002-10-11T00:00:00.000Z indicates that parts created before 2002-10-11T00:00:00.000Z are deleted, and parts created after this time (including this time) are not deleted.
-        """
         return pulumi.get(self, "created_before_date")
 
     @property
     @pulumi.getter
     def date(self) -> Optional[str]:
-        """
-        Specifies the date after which you want the corresponding action to take effect. The value obeys ISO8601 format like `2017-03-09`.
-        """
         return pulumi.get(self, "date")
 
     @property
     @pulumi.getter
     def days(self) -> Optional[int]:
-        """
-        Specifies the number of days noncurrent object versions transition.
-        """
         return pulumi.get(self, "days")
 
     @property
     @pulumi.getter(name="expiredObjectDeleteMarker")
     def expired_object_delete_marker(self) -> Optional[bool]:
-        """
-        On a versioned bucket (versioning-enabled or versioning-suspended bucket), you can add this element in the lifecycle configuration to direct OSS to delete expired object delete markers. This cannot be specified with Days, Date or CreatedBeforeDate in a Lifecycle Expiration Policy.
-
-        `NOTE`: One and only one of "date", "days", "created_before_date" and "expired_object_delete_marker" can be specified in one expiration configuration.
-        """
         return pulumi.get(self, "expired_object_delete_marker")
 
 
@@ -556,11 +524,6 @@ class BucketLifecycleRuleFilter(dict):
                  not_: Optional['outputs.BucketLifecycleRuleFilterNot'] = None,
                  object_size_greater_than: Optional[int] = None,
                  object_size_less_than: Optional[int] = None):
-        """
-        :param 'BucketLifecycleRuleFilterNotArgs' not_: The condition that is matched by objects to which the lifecycle rule does not apply. See `not` below.
-        :param int object_size_greater_than: Minimum object size (in bytes) to which the rule applies.
-        :param int object_size_less_than: Maximum object size (in bytes) to which the rule applies.
-        """
         if not_ is not None:
             pulumi.set(__self__, "not_", not_)
         if object_size_greater_than is not None:
@@ -571,25 +534,16 @@ class BucketLifecycleRuleFilter(dict):
     @property
     @pulumi.getter(name="not")
     def not_(self) -> Optional['outputs.BucketLifecycleRuleFilterNot']:
-        """
-        The condition that is matched by objects to which the lifecycle rule does not apply. See `not` below.
-        """
         return pulumi.get(self, "not_")
 
     @property
     @pulumi.getter(name="objectSizeGreaterThan")
     def object_size_greater_than(self) -> Optional[int]:
-        """
-        Minimum object size (in bytes) to which the rule applies.
-        """
         return pulumi.get(self, "object_size_greater_than")
 
     @property
     @pulumi.getter(name="objectSizeLessThan")
     def object_size_less_than(self) -> Optional[int]:
-        """
-        Maximum object size (in bytes) to which the rule applies.
-        """
         return pulumi.get(self, "object_size_less_than")
 
 
@@ -598,10 +552,6 @@ class BucketLifecycleRuleFilterNot(dict):
     def __init__(__self__, *,
                  prefix: Optional[str] = None,
                  tag: Optional['outputs.BucketLifecycleRuleFilterNotTag'] = None):
-        """
-        :param str prefix: The prefix in the names of the objects to which the lifecycle rule does not apply.
-        :param 'BucketLifecycleRuleFilterNotTagArgs' tag: The tag of the objects to which the lifecycle rule does not apply. See `tag` below.
-        """
         if prefix is not None:
             pulumi.set(__self__, "prefix", prefix)
         if tag is not None:
@@ -610,17 +560,11 @@ class BucketLifecycleRuleFilterNot(dict):
     @property
     @pulumi.getter
     def prefix(self) -> Optional[str]:
-        """
-        The prefix in the names of the objects to which the lifecycle rule does not apply.
-        """
         return pulumi.get(self, "prefix")
 
     @property
     @pulumi.getter
     def tag(self) -> Optional['outputs.BucketLifecycleRuleFilterNotTag']:
-        """
-        The tag of the objects to which the lifecycle rule does not apply. See `tag` below.
-        """
         return pulumi.get(self, "tag")
 
 
@@ -629,27 +573,17 @@ class BucketLifecycleRuleFilterNotTag(dict):
     def __init__(__self__, *,
                  key: str,
                  value: str):
-        """
-        :param str key: The key of the tag that is specified for the objects.
-        :param str value: The value of the tag that is specified for the objects.
-        """
         pulumi.set(__self__, "key", key)
         pulumi.set(__self__, "value", value)
 
     @property
     @pulumi.getter
     def key(self) -> str:
-        """
-        The key of the tag that is specified for the objects.
-        """
         return pulumi.get(self, "key")
 
     @property
     @pulumi.getter
     def value(self) -> str:
-        """
-        The value of the tag that is specified for the objects.
-        """
         return pulumi.get(self, "value")
 
 
@@ -657,17 +591,11 @@ class BucketLifecycleRuleFilterNotTag(dict):
 class BucketLifecycleRuleNoncurrentVersionExpiration(dict):
     def __init__(__self__, *,
                  days: int):
-        """
-        :param int days: Specifies the number of days noncurrent object versions transition.
-        """
         pulumi.set(__self__, "days", days)
 
     @property
     @pulumi.getter
     def days(self) -> int:
-        """
-        Specifies the number of days noncurrent object versions transition.
-        """
         return pulumi.get(self, "days")
 
 
@@ -700,10 +628,7 @@ class BucketLifecycleRuleNoncurrentVersionTransition(dict):
                  is_access_time: Optional[bool] = None,
                  return_to_std_when_visit: Optional[bool] = None):
         """
-        :param int days: Specifies the number of days noncurrent object versions transition.
         :param str storage_class: The [storage class](https://www.alibabacloud.com/help/doc-detail/51374.htm) to apply. Can be "Standard", "IA", "Archive", "ColdArchive" and "DeepColdArchive". Defaults to "Standard". "ColdArchive" is available since 1.203.0. "DeepColdArchive" is available since 1.209.0.
-        :param bool is_access_time: Specifies whether the lifecycle rule applies to objects based on their last access time. If set to `true`, the rule applies to objects based on their last access time; if set to `false`, the rule applies to objects based on their last modified time. If configure the rule based on the last access time, please enable `access_monitor` first.
-        :param bool return_to_std_when_visit: Specifies whether to convert the storage class of non-Standard objects back to Standard after the objects are accessed. It takes effect only when the IsAccessTime parameter is set to true. If set to `true`, converts the storage class of the objects to Standard; if set to `false`, does not convert the storage class of the objects to Standard.
         """
         pulumi.set(__self__, "days", days)
         pulumi.set(__self__, "storage_class", storage_class)
@@ -715,9 +640,6 @@ class BucketLifecycleRuleNoncurrentVersionTransition(dict):
     @property
     @pulumi.getter
     def days(self) -> int:
-        """
-        Specifies the number of days noncurrent object versions transition.
-        """
         return pulumi.get(self, "days")
 
     @property
@@ -731,17 +653,11 @@ class BucketLifecycleRuleNoncurrentVersionTransition(dict):
     @property
     @pulumi.getter(name="isAccessTime")
     def is_access_time(self) -> Optional[bool]:
-        """
-        Specifies whether the lifecycle rule applies to objects based on their last access time. If set to `true`, the rule applies to objects based on their last access time; if set to `false`, the rule applies to objects based on their last modified time. If configure the rule based on the last access time, please enable `access_monitor` first.
-        """
         return pulumi.get(self, "is_access_time")
 
     @property
     @pulumi.getter(name="returnToStdWhenVisit")
     def return_to_std_when_visit(self) -> Optional[bool]:
-        """
-        Specifies whether to convert the storage class of non-Standard objects back to Standard after the objects are accessed. It takes effect only when the IsAccessTime parameter is set to true. If set to `true`, converts the storage class of the objects to Standard; if set to `false`, does not convert the storage class of the objects to Standard.
-        """
         return pulumi.get(self, "return_to_std_when_visit")
 
 
@@ -778,10 +694,6 @@ class BucketLifecycleRuleTransition(dict):
                  return_to_std_when_visit: Optional[bool] = None):
         """
         :param str storage_class: The [storage class](https://www.alibabacloud.com/help/doc-detail/51374.htm) to apply. Can be "Standard", "IA", "Archive", "ColdArchive" and "DeepColdArchive". Defaults to "Standard". "ColdArchive" is available since 1.203.0. "DeepColdArchive" is available since 1.209.0.
-        :param str created_before_date: Specifies the time before which the rules take effect. The date must conform to the ISO8601 format and always be UTC 00:00. For example: 2002-10-11T00:00:00.000Z indicates that parts created before 2002-10-11T00:00:00.000Z are deleted, and parts created after this time (including this time) are not deleted.
-        :param int days: Specifies the number of days noncurrent object versions transition.
-        :param bool is_access_time: Specifies whether the lifecycle rule applies to objects based on their last access time. If set to `true`, the rule applies to objects based on their last access time; if set to `false`, the rule applies to objects based on their last modified time. If configure the rule based on the last access time, please enable `access_monitor` first.
-        :param bool return_to_std_when_visit: Specifies whether to convert the storage class of non-Standard objects back to Standard after the objects are accessed. It takes effect only when the IsAccessTime parameter is set to true. If set to `true`, converts the storage class of the objects to Standard; if set to `false`, does not convert the storage class of the objects to Standard.
         """
         pulumi.set(__self__, "storage_class", storage_class)
         if created_before_date is not None:
@@ -804,33 +716,21 @@ class BucketLifecycleRuleTransition(dict):
     @property
     @pulumi.getter(name="createdBeforeDate")
     def created_before_date(self) -> Optional[str]:
-        """
-        Specifies the time before which the rules take effect. The date must conform to the ISO8601 format and always be UTC 00:00. For example: 2002-10-11T00:00:00.000Z indicates that parts created before 2002-10-11T00:00:00.000Z are deleted, and parts created after this time (including this time) are not deleted.
-        """
         return pulumi.get(self, "created_before_date")
 
     @property
     @pulumi.getter
     def days(self) -> Optional[int]:
-        """
-        Specifies the number of days noncurrent object versions transition.
-        """
         return pulumi.get(self, "days")
 
     @property
     @pulumi.getter(name="isAccessTime")
     def is_access_time(self) -> Optional[bool]:
-        """
-        Specifies whether the lifecycle rule applies to objects based on their last access time. If set to `true`, the rule applies to objects based on their last access time; if set to `false`, the rule applies to objects based on their last modified time. If configure the rule based on the last access time, please enable `access_monitor` first.
-        """
         return pulumi.get(self, "is_access_time")
 
     @property
     @pulumi.getter(name="returnToStdWhenVisit")
     def return_to_std_when_visit(self) -> Optional[bool]:
-        """
-        Specifies whether to convert the storage class of non-Standard objects back to Standard after the objects are accessed. It takes effect only when the IsAccessTime parameter is set to true. If set to `true`, converts the storage class of the objects to Standard; if set to `false`, does not convert the storage class of the objects to Standard.
-        """
         return pulumi.get(self, "return_to_std_when_visit")
 
 

pulumi_alicloud/ots/_inputs.py

@@ -84,15 +84,6 @@ class SearchIndexSchemaFieldSchemaArgs:
                  index: Optional[pulumi.Input[bool]] = None,
                  is_array: Optional[pulumi.Input[bool]] = None,
                  store: Optional[pulumi.Input[bool]] = None):
-        """
-        :param pulumi.Input[str] field_name: The name of the field that is used to sort data. only required if sorter_type is FieldSort.
-        :param pulumi.Input[str] field_type: Specifies the type of the field. Use FieldType.XXX to set the type.
-        :param pulumi.Input[str] analyzer: Specifies the type of the analyzer that you want to use. If fieldType is set to Text, you can configure this parameter. Otherwise, the default analyzer type single-word tokenization is used.
-        :param pulumi.Input[bool] enable_sort_and_agg: Specifies whether to enable sorting and aggregation. Type: Boolean. Sorting can be enabled only for fields for which enable_sort_and_agg is set to true.
-        :param pulumi.Input[bool] index: Specifies whether to enable indexing for the column. Type: Boolean.
-        :param pulumi.Input[bool] is_array: Specifies whether the value is an array. Type: Boolean.
-        :param pulumi.Input[bool] store: Specifies whether to store the value of the field in the search index. Type: Boolean. If you set store to true, you can read the value of the field from the search index without querying the data table. This improves query performance.
-        """
         pulumi.set(__self__, "field_name", field_name)
         pulumi.set(__self__, "field_type", field_type)
         if analyzer is not None:
@@ -109,9 +100,6 @@ class SearchIndexSchemaFieldSchemaArgs:
     @property
     @pulumi.getter(name="fieldName")
     def field_name(self) -> pulumi.Input[str]:
-        """
-        The name of the field that is used to sort data. only required if sorter_type is FieldSort.
-        """
         return pulumi.get(self, "field_name")
 
     @field_name.setter
@@ -121,9 +109,6 @@ class SearchIndexSchemaFieldSchemaArgs:
     @property
     @pulumi.getter(name="fieldType")
     def field_type(self) -> pulumi.Input[str]:
-        """
-        Specifies the type of the field. Use FieldType.XXX to set the type.
-        """
         return pulumi.get(self, "field_type")
 
     @field_type.setter
@@ -133,9 +118,6 @@ class SearchIndexSchemaFieldSchemaArgs:
     @property
     @pulumi.getter
     def analyzer(self) -> Optional[pulumi.Input[str]]:
-        """
-        Specifies the type of the analyzer that you want to use. If fieldType is set to Text, you can configure this parameter. Otherwise, the default analyzer type single-word tokenization is used.
-        """
         return pulumi.get(self, "analyzer")
 
     @analyzer.setter
@@ -145,9 +127,6 @@ class SearchIndexSchemaFieldSchemaArgs:
     @property
     @pulumi.getter(name="enableSortAndAgg")
     def enable_sort_and_agg(self) -> Optional[pulumi.Input[bool]]:
-        """
-        Specifies whether to enable sorting and aggregation. Type: Boolean. Sorting can be enabled only for fields for which enable_sort_and_agg is set to true.
-        """
         return pulumi.get(self, "enable_sort_and_agg")
 
     @enable_sort_and_agg.setter
@@ -157,9 +136,6 @@ class SearchIndexSchemaFieldSchemaArgs:
     @property
     @pulumi.getter
     def index(self) -> Optional[pulumi.Input[bool]]:
-        """
-        Specifies whether to enable indexing for the column. Type: Boolean.
-        """
         return pulumi.get(self, "index")
 
     @index.setter
@@ -169,9 +145,6 @@ class SearchIndexSchemaFieldSchemaArgs:
     @property
     @pulumi.getter(name="isArray")
     def is_array(self) -> Optional[pulumi.Input[bool]]:
-        """
-        Specifies whether the value is an array. Type: Boolean.
-        """
         return pulumi.get(self, "is_array")
 
     @is_array.setter
@@ -181,9 +154,6 @@ class SearchIndexSchemaFieldSchemaArgs:
     @property
     @pulumi.getter
     def store(self) -> Optional[pulumi.Input[bool]]:
-        """
-        Specifies whether to store the value of the field in the search index. Type: Boolean. If you set store to true, you can read the value of the field from the search index without querying the data table. This improves query performance.
-        """
         return pulumi.get(self, "store")
 
     @store.setter
@@ -195,18 +165,12 @@ class SearchIndexSchemaFieldSchemaArgs:
 class SearchIndexSchemaIndexSettingArgs:
     def __init__(__self__, *,
                  routing_fields: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
-        """
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] routing_fields: Specifies custom routing fields. You can specify some primary key columns as routing fields. Tablestore distributes data that is written to a search index across different partitions based on the specified routing fields. The data whose routing field values are the same is distributed to the same partition.
-        """
         if routing_fields is not None:
             pulumi.set(__self__, "routing_fields", routing_fields)
 
     @property
     @pulumi.getter(name="routingFields")
     def routing_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
-        """
-        Specifies custom routing fields. You can specify some primary key columns as routing fields. Tablestore distributes data that is written to a search index across different partitions based on the specified routing fields. The data whose routing field values are the same is distributed to the same partition.
-        """
         return pulumi.get(self, "routing_fields")
 
     @routing_fields.setter
@@ -218,17 +182,11 @@ class SearchIndexSchemaIndexSettingArgs:
 class SearchIndexSchemaIndexSortArgs:
     def __init__(__self__, *,
                  sorters: pulumi.Input[Sequence[pulumi.Input['SearchIndexSchemaIndexSortSorterArgs']]]):
-        """
-        :param pulumi.Input[Sequence[pulumi.Input['SearchIndexSchemaIndexSortSorterArgs']]] sorters: Specifies the presorting method for the search index. PrimaryKeySort and FieldSort are supported. See `sorter` below.
-        """
         pulumi.set(__self__, "sorters", sorters)
 
     @property
     @pulumi.getter
     def sorters(self) -> pulumi.Input[Sequence[pulumi.Input['SearchIndexSchemaIndexSortSorterArgs']]]:
-        """
-        Specifies the presorting method for the search index. PrimaryKeySort and FieldSort are supported. See `sorter` below.
-        """
         return pulumi.get(self, "sorters")
 
     @sorters.setter
@@ -243,12 +201,6 @@ class SearchIndexSchemaIndexSortSorterArgs:
                  mode: Optional[pulumi.Input[str]] = None,
                  order: Optional[pulumi.Input[str]] = None,
                  sorter_type: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input[str] field_name: The name of the field that is used to sort data. only required if sorter_type is FieldSort.
-        :param pulumi.Input[str] mode: The sorting method that is used when the field contains multiple values. valid values: `Min`, `Max`, `Avg`. only required if sorter_type is FieldSort.
-        :param pulumi.Input[str] order: The sort order. Data can be sorted in ascending(`Asc`) or descending(`Desc`) order. Default value: `Asc`.
-        :param pulumi.Input[str] sorter_type: Data is sorted by Which fields or keys. valid values: `PrimaryKeySort`, `FieldSort`.
-        """
         if field_name is not None:
             pulumi.set(__self__, "field_name", field_name)
         if mode is not None:
@@ -261,9 +213,6 @@ class SearchIndexSchemaIndexSortSorterArgs:
     @property
     @pulumi.getter(name="fieldName")
     def field_name(self) -> Optional[pulumi.Input[str]]:
-        """
-        The name of the field that is used to sort data. only required if sorter_type is FieldSort.
-        """
         return pulumi.get(self, "field_name")
 
     @field_name.setter
@@ -273,9 +222,6 @@ class SearchIndexSchemaIndexSortSorterArgs:
     @property
     @pulumi.getter
     def mode(self) -> Optional[pulumi.Input[str]]:
-        """
-        The sorting method that is used when the field contains multiple values. valid values: `Min`, `Max`, `Avg`. only required if sorter_type is FieldSort.
-        """
         return pulumi.get(self, "mode")
 
     @mode.setter
@@ -285,9 +231,6 @@ class SearchIndexSchemaIndexSortSorterArgs:
     @property
     @pulumi.getter
     def order(self) -> Optional[pulumi.Input[str]]:
-        """
-        The sort order. Data can be sorted in ascending(`Asc`) or descending(`Desc`) order. Default value: `Asc`.
-        """
         return pulumi.get(self, "order")
 
     @order.setter
@@ -297,9 +240,6 @@ class SearchIndexSchemaIndexSortSorterArgs:
     @property
     @pulumi.getter(name="sorterType")
     def sorter_type(self) -> Optional[pulumi.Input[str]]:
-        """
-        Data is sorted by Which fields or keys. valid values: `PrimaryKeySort`, `FieldSort`.
-        """
         return pulumi.get(self, "sorter_type")
 
     @sorter_type.setter

pulumi_alicloud/ots/outputs.py

@@ -126,15 +126,6 @@ class SearchIndexSchemaFieldSchema(dict):
                  index: Optional[bool] = None,
                  is_array: Optional[bool] = None,
                  store: Optional[bool] = None):
-        """
-        :param str field_name: The name of the field that is used to sort data. only required if sorter_type is FieldSort.
-        :param str field_type: Specifies the type of the field. Use FieldType.XXX to set the type.
-        :param str analyzer: Specifies the type of the analyzer that you want to use. If fieldType is set to Text, you can configure this parameter. Otherwise, the default analyzer type single-word tokenization is used.
-        :param bool enable_sort_and_agg: Specifies whether to enable sorting and aggregation. Type: Boolean. Sorting can be enabled only for fields for which enable_sort_and_agg is set to true.
-        :param bool index: Specifies whether to enable indexing for the column. Type: Boolean.
-        :param bool is_array: Specifies whether the value is an array. Type: Boolean.
-        :param bool store: Specifies whether to store the value of the field in the search index. Type: Boolean. If you set store to true, you can read the value of the field from the search index without querying the data table. This improves query performance.
-        """
         pulumi.set(__self__, "field_name", field_name)
         pulumi.set(__self__, "field_type", field_type)
         if analyzer is not None:
@@ -151,57 +142,36 @@ class SearchIndexSchemaFieldSchema(dict):
     @property
     @pulumi.getter(name="fieldName")
     def field_name(self) -> str:
-        """
-        The name of the field that is used to sort data. only required if sorter_type is FieldSort.
-        """
         return pulumi.get(self, "field_name")
 
     @property
     @pulumi.getter(name="fieldType")
     def field_type(self) -> str:
-        """
-        Specifies the type of the field. Use FieldType.XXX to set the type.
-        """
         return pulumi.get(self, "field_type")
 
     @property
     @pulumi.getter
     def analyzer(self) -> Optional[str]:
-        """
-        Specifies the type of the analyzer that you want to use. If fieldType is set to Text, you can configure this parameter. Otherwise, the default analyzer type single-word tokenization is used.
-        """
         return pulumi.get(self, "analyzer")
 
     @property
     @pulumi.getter(name="enableSortAndAgg")
     def enable_sort_and_agg(self) -> Optional[bool]:
-        """
-        Specifies whether to enable sorting and aggregation. Type: Boolean. Sorting can be enabled only for fields for which enable_sort_and_agg is set to true.
-        """
         return pulumi.get(self, "enable_sort_and_agg")
 
     @property
     @pulumi.getter
     def index(self) -> Optional[bool]:
-        """
-        Specifies whether to enable indexing for the column. Type: Boolean.
-        """
         return pulumi.get(self, "index")
 
     @property
     @pulumi.getter(name="isArray")
     def is_array(self) -> Optional[bool]:
-        """
-        Specifies whether the value is an array. Type: Boolean.
-        """
         return pulumi.get(self, "is_array")
 
     @property
     @pulumi.getter
     def store(self) -> Optional[bool]:
-        """
-        Specifies whether to store the value of the field in the search index. Type: Boolean. If you set store to true, you can read the value of the field from the search index without querying the data table. This improves query performance.
-        """
         return pulumi.get(self, "store")
 
 
@@ -226,18 +196,12 @@ class SearchIndexSchemaIndexSetting(dict):
 
     def __init__(__self__, *,
                  routing_fields: Optional[Sequence[str]] = None):
-        """
-        :param Sequence[str] routing_fields: Specifies custom routing fields. You can specify some primary key columns as routing fields. Tablestore distributes data that is written to a search index across different partitions based on the specified routing fields. The data whose routing field values are the same is distributed to the same partition.
-        """
         if routing_fields is not None:
             pulumi.set(__self__, "routing_fields", routing_fields)
 
     @property
     @pulumi.getter(name="routingFields")
     def routing_fields(self) -> Optional[Sequence[str]]:
-        """
-        Specifies custom routing fields. You can specify some primary key columns as routing fields. Tablestore distributes data that is written to a search index across different partitions based on the specified routing fields. The data whose routing field values are the same is distributed to the same partition.
-        """
         return pulumi.get(self, "routing_fields")
 
 
@@ -245,17 +209,11 @@ class SearchIndexSchemaIndexSetting(dict):
 class SearchIndexSchemaIndexSort(dict):
     def __init__(__self__, *,
                  sorters: Sequence['outputs.SearchIndexSchemaIndexSortSorter']):
-        """
-        :param Sequence['SearchIndexSchemaIndexSortSorterArgs'] sorters: Specifies the presorting method for the search index. PrimaryKeySort and FieldSort are supported. See `sorter` below.
-        """
         pulumi.set(__self__, "sorters", sorters)
 
     @property
     @pulumi.getter
     def sorters(self) -> Sequence['outputs.SearchIndexSchemaIndexSortSorter']:
-        """
-        Specifies the presorting method for the search index. PrimaryKeySort and FieldSort are supported. See `sorter` below.
-        """
         return pulumi.get(self, "sorters")
 
 
@@ -285,12 +243,6 @@ class SearchIndexSchemaIndexSortSorter(dict):
                  mode: Optional[str] = None,
                  order: Optional[str] = None,
                  sorter_type: Optional[str] = None):
-        """
-        :param str field_name: The name of the field that is used to sort data. only required if sorter_type is FieldSort.
-        :param str mode: The sorting method that is used when the field contains multiple values. valid values: `Min`, `Max`, `Avg`. only required if sorter_type is FieldSort.
-        :param str order: The sort order. Data can be sorted in ascending(`Asc`) or descending(`Desc`) order. Default value: `Asc`.
-        :param str sorter_type: Data is sorted by Which fields or keys. valid values: `PrimaryKeySort`, `FieldSort`.
-        """
         if field_name is not None:
             pulumi.set(__self__, "field_name", field_name)
         if mode is not None:
@@ -303,33 +255,21 @@ class SearchIndexSchemaIndexSortSorter(dict):
     @property
     @pulumi.getter(name="fieldName")
     def field_name(self) -> Optional[str]:
-        """
-        The name of the field that is used to sort data. only required if sorter_type is FieldSort.
-        """
         return pulumi.get(self, "field_name")
 
     @property
     @pulumi.getter
     def mode(self) -> Optional[str]:
-        """
-        The sorting method that is used when the field contains multiple values. valid values: `Min`, `Max`, `Avg`. only required if sorter_type is FieldSort.
-        """
         return pulumi.get(self, "mode")
 
     @property
     @pulumi.getter
     def order(self) -> Optional[str]:
-        """
-        The sort order. Data can be sorted in ascending(`Asc`) or descending(`Desc`) order. Default value: `Asc`.
-        """
         return pulumi.get(self, "order")
 
     @property
     @pulumi.getter(name="sorterType")
     def sorter_type(self) -> Optional[str]:
-        """
-        Data is sorted by Which fields or keys. valid values: `PrimaryKeySort`, `FieldSort`.
-        """
         return pulumi.get(self, "sorter_type")