rapidata 2.36.0__py3-none-any.whl → 2.36.2__py3-none-any.whl

rapidata/api_client/models/image_dimension_metadata.py

@@ -29,7 +29,7 @@ class ImageDimensionMetadata(BaseModel):
     t: StrictStr = Field(description="Discriminator value for ImageDimensionMetadata", alias="_t")
     height: Optional[StrictInt] = None
     width: Optional[StrictInt] = None
-    visibilities: Optional[StrictStr] = None
+    visibilities: Optional[List[StrictStr]] = None
     __properties: ClassVar[List[str]] = ["_t", "height", "width", "visibilities"]
 
     @field_validator('t')
@@ -39,6 +39,17 @@ class ImageDimensionMetadata(BaseModel):
             raise ValueError("must be one of enum values ('ImageDimensionMetadata')")
         return value
 
+    @field_validator('visibilities')
+    def visibilities_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        for i in value:
+            if i not in set(['None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All']):
+                raise ValueError("each list item must be one of ('None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All')")
+        return value
+
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/labeling_selection.py

@@ -19,6 +19,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
+from rapidata.api_client.models.retrieval_mode import RetrievalMode
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -28,7 +29,7 @@ class LabelingSelection(BaseModel):
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for LabelingSelection", alias="_t")
     amount: StrictInt
-    retrieval_mode: Optional[StrictStr] = Field(default=None, alias="retrievalMode")
+    retrieval_mode: Optional[RetrievalMode] = Field(default=None, alias="retrievalMode")
     max_iterations: Optional[StrictInt] = Field(default=None, alias="maxIterations")
     __properties: ClassVar[List[str]] = ["_t", "amount", "retrievalMode", "maxIterations"]
 
@@ -39,16 +40,6 @@ class LabelingSelection(BaseModel):
             raise ValueError("must be one of enum values ('LabelingSelection')")
         return value
 
-    @field_validator('retrieval_mode')
-    def retrieval_mode_validate_enum(cls, value):
-        """Validates the enum"""
-        if value is None:
-            return value
-
-        if value not in set(['Random', 'Shuffled', 'Sequential']):
-            raise ValueError("must be one of enum values ('Random', 'Shuffled', 'Sequential')")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/location_metadata.py

@@ -29,7 +29,7 @@ class LocationMetadata(BaseModel):
     t: StrictStr = Field(description="Discriminator value for LocationMetadata", alias="_t")
     x: Union[StrictFloat, StrictInt]
     y: Union[StrictFloat, StrictInt]
-    visibilities: Optional[StrictStr] = None
+    visibilities: Optional[List[StrictStr]] = None
     __properties: ClassVar[List[str]] = ["_t", "x", "y", "visibilities"]
 
     @field_validator('t')
@@ -39,6 +39,17 @@ class LocationMetadata(BaseModel):
             raise ValueError("must be one of enum values ('LocationMetadata')")
         return value
 
+    @field_validator('visibilities')
+    def visibilities_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        for i in value:
+            if i not in set(['None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All']):
+                raise ValueError("each list item must be one of ('None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All')")
+        return value
+
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/order_model.py

@@ -18,8 +18,9 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
-from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
+from rapidata.api_client.models.order_state import OrderState
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -31,18 +32,11 @@ class OrderModel(BaseModel):
     pipeline_id: StrictStr = Field(alias="pipelineId")
     order_date: Optional[datetime] = Field(default=None, alias="orderDate")
     customer_mail: StrictStr = Field(alias="customerMail")
-    state: StrictStr
+    state: OrderState
     order_name: StrictStr = Field(alias="orderName")
     is_public: StrictBool = Field(alias="isPublic")
     __properties: ClassVar[List[str]] = ["id", "pipelineId", "orderDate", "customerMail", "state", "orderName", "isPublic"]
 
-    @field_validator('state')
-    def state_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Created', 'Preview', 'Submitted', 'ManualReview', 'Processing', 'Paused', 'Completed', 'Cancelled', 'Failed']):
-            raise ValueError("must be one of enum values ('Created', 'Preview', 'Submitted', 'ManualReview', 'Processing', 'Paused', 'Completed', 'Cancelled', 'Failed')")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/original_filename_metadata.py

@@ -28,7 +28,7 @@ class OriginalFilenameMetadata(BaseModel):
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for OriginalFilenameMetadata", alias="_t")
     original_filename: StrictStr = Field(alias="originalFilename")
-    visibilities: Optional[StrictStr] = None
+    visibilities: Optional[List[StrictStr]] = None
     __properties: ClassVar[List[str]] = ["_t", "originalFilename", "visibilities"]
 
     @field_validator('t')
@@ -38,6 +38,17 @@ class OriginalFilenameMetadata(BaseModel):
             raise ValueError("must be one of enum values ('OriginalFilenameMetadata')")
         return value
 
+    @field_validator('visibilities')
+    def visibilities_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        for i in value:
+            if i not in set(['None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All']):
+                raise ValueError("each list item must be one of ('None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All')")
+        return value
+
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/participant_by_benchmark.py

@@ -17,8 +17,9 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
 from typing import Any, ClassVar, Dict, List
+from rapidata.api_client.models.participant_status import ParticipantStatus
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -30,16 +31,9 @@ class ParticipantByBenchmark(BaseModel):
     name: StrictStr
     benchmark_id: StrictStr = Field(alias="benchmarkId")
     dataset_id: StrictStr = Field(alias="datasetId")
-    status: StrictStr
+    status: ParticipantStatus
     __properties: ClassVar[List[str]] = ["id", "name", "benchmarkId", "datasetId", "status"]
 
-    @field_validator('status')
-    def status_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Created', 'Submitted', 'Disabled']):
-            raise ValueError("must be one of enum values ('Created', 'Submitted', 'Disabled')")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/prompt_metadata.py

@@ -28,7 +28,7 @@ class PromptMetadata(BaseModel):
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for PromptMetadata", alias="_t")
     prompt: StrictStr
-    visibilities: Optional[StrictStr] = None
+    visibilities: Optional[List[StrictStr]] = None
     __properties: ClassVar[List[str]] = ["_t", "prompt", "visibilities"]
 
     @field_validator('t')
@@ -38,6 +38,17 @@ class PromptMetadata(BaseModel):
             raise ValueError("must be one of enum values ('PromptMetadata')")
         return value
 
+    @field_validator('visibilities')
+    def visibilities_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        for i in value:
+            if i not in set(['None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All']):
+                raise ValueError("each list item must be one of ('None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All')")
+        return value
+
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/prompt_type.py

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+"""
+    Rapidata.Dataset
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class PromptType(str, Enum):
+    """
+    PromptType
+    """
+
+    """
+    allowed enum values
+    """
+    NONE = 'None'
+    TEXT = 'Text'
+    ASSET = 'Asset'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of PromptType from a JSON string"""
+        return cls(json.loads(json_str))
+
+

rapidata/api_client/models/rapid_modality.py

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+"""
+    Rapidata.Dataset
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class RapidModality(str, Enum):
+    """
+    RapidModality
+    """
+
+    """
+    allowed enum values
+    """
+    NONE = 'None'
+    BOUNDINGBOX = 'BoundingBox'
+    CLASSIFY = 'Classify'
+    COMPARE = 'Compare'
+    FREETEXT = 'FreeText'
+    LINE = 'Line'
+    LOCATE = 'Locate'
+    NAMEDENTITY = 'NamedEntity'
+    POLYGON = 'Polygon'
+    SCRUB = 'Scrub'
+    TRANSCRIPTION = 'Transcription'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of RapidModality from a JSON string"""
+        return cls(json.loads(json_str))
+
+

rapidata/api_client/models/rapid_model.py

@@ -18,13 +18,14 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
-from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional, Union
 from rapidata.api_client.models.datapoint_asset import DatapointAsset
 from rapidata.api_client.models.file_asset_model_metadata_value import FileAssetModelMetadataValue
 from rapidata.api_client.models.get_validation_rapids_result_payload import GetValidationRapidsResultPayload
 from rapidata.api_client.models.get_validation_rapids_result_truth import GetValidationRapidsResultTruth
 from rapidata.api_client.models.rapid_model_referee import RapidModelReferee
+from rapidata.api_client.models.rapid_state import RapidState
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -37,7 +38,7 @@ class RapidModel(BaseModel):
     referee: RapidModelReferee
     asset: DatapointAsset
     metadata: Dict[str, FileAssetModelMetadataValue]
-    state: StrictStr
+    state: RapidState
     has_responses: StrictBool = Field(alias="hasResponses")
     should_accept_incorrect: StrictBool = Field(alias="shouldAcceptIncorrect")
     truth: Optional[GetValidationRapidsResultTruth] = None
@@ -47,13 +48,6 @@ class RapidModel(BaseModel):
     completed_at: Optional[datetime] = Field(default=None, alias="completedAt")
     __properties: ClassVar[List[str]] = ["id", "payload", "referee", "asset", "metadata", "state", "hasResponses", "shouldAcceptIncorrect", "truth", "explanation", "randomCorrectProbability", "key", "completedAt"]
 
-    @field_validator('state')
-    def state_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Labeling', 'Paused', 'Incomplete', 'Flagged', 'Done', 'None']):
-            raise ValueError("must be one of enum values ('Labeling', 'Paused', 'Incomplete', 'Flagged', 'Done', 'None')")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/report_model.py

@@ -17,8 +17,9 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
+from rapidata.api_client.models.rapid_issue import RapidIssue
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -26,19 +27,12 @@ class ReportModel(BaseModel):
     """
     The model for reporting an issue with a rapid.
     """ # noqa: E501
-    issue: StrictStr
+    issue: RapidIssue
     message: Optional[StrictStr] = Field(default=None, description="An optional message typed by the user.")
     dump: Optional[StrictStr] = Field(default=None, description="A dump, that the frontend defines and can read again.")
     source: Optional[StrictStr] = Field(default=None, description="An optional identifier where the report originated from.")
     __properties: ClassVar[List[str]] = ["issue", "message", "dump", "source"]
 
-    @field_validator('issue')
-    def issue_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Other', 'CannotSubmit', 'NoAsset', 'Inappropriate', 'NoCorrectOption', 'WrongLanguage', 'DoNotUnderstand', 'DoNotCare', 'NotSeeOptionsOrMediaDidntLoad', 'MyAnswerIsCorrect']):
-            raise ValueError("must be one of enum values ('Other', 'CannotSubmit', 'NoAsset', 'Inappropriate', 'NoCorrectOption', 'WrongLanguage', 'DoNotUnderstand', 'DoNotCare', 'NotSeeOptionsOrMediaDidntLoad', 'MyAnswerIsCorrect')")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/response_count_filter.py

@@ -19,6 +19,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
+from rapidata.api_client.models.comparison_operator import ComparisonOperator
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -29,7 +30,7 @@ class ResponseCountFilter(BaseModel):
     t: StrictStr = Field(description="Discriminator value for ResponseCountFilter", alias="_t")
     response_count: StrictInt = Field(alias="responseCount")
     dimension: StrictStr
-    operator: StrictStr
+    operator: ComparisonOperator
     execution_order: Optional[StrictInt] = Field(default=None, alias="executionOrder")
     __properties: ClassVar[List[str]] = ["_t", "responseCount", "dimension", "operator", "executionOrder"]
 
@@ -40,13 +41,6 @@ class ResponseCountFilter(BaseModel):
             raise ValueError("must be one of enum values ('ResponseCountFilter')")
         return value
 
-    @field_validator('operator')
-    def operator_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Equal', 'NotEqual', 'LessThan', 'LessThanOrEqual', 'GreaterThan', 'GreaterThanOrEqual']):
-            raise ValueError("must be one of enum values ('Equal', 'NotEqual', 'LessThan', 'LessThanOrEqual', 'GreaterThan', 'GreaterThanOrEqual')")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/response_count_user_filter_model.py

@@ -19,6 +19,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List
+from rapidata.api_client.models.comparison_operator import ComparisonOperator
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -29,7 +30,7 @@ class ResponseCountUserFilterModel(BaseModel):
     t: StrictStr = Field(description="Discriminator value for ResponseCountFilter", alias="_t")
     response_count: StrictInt = Field(alias="responseCount")
     dimension: StrictStr
-    operator: StrictStr
+    operator: ComparisonOperator
     __properties: ClassVar[List[str]] = ["_t", "responseCount", "dimension", "operator"]
 
     @field_validator('t')
@@ -39,13 +40,6 @@ class ResponseCountUserFilterModel(BaseModel):
             raise ValueError("must be one of enum values ('ResponseCountFilter')")
         return value
 
-    @field_validator('operator')
-    def operator_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Equal', 'NotEqual', 'LessThan', 'LessThanOrEqual', 'GreaterThan', 'GreaterThanOrEqual']):
-            raise ValueError("must be one of enum values ('Equal', 'NotEqual', 'LessThan', 'LessThanOrEqual', 'GreaterThan', 'GreaterThanOrEqual')")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/root_filter.py

@@ -17,9 +17,10 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict
 from typing import Any, ClassVar, Dict, List, Optional
 from rapidata.api_client.models.filter import Filter
+from rapidata.api_client.models.logic_operator import LogicOperator
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -28,19 +29,9 @@ class RootFilter(BaseModel):
     RootFilter
     """ # noqa: E501
     filters: Optional[List[Filter]] = None
-    logic: Optional[StrictStr] = None
+    logic: Optional[LogicOperator] = None
     __properties: ClassVar[List[str]] = ["filters", "logic"]
 
-    @field_validator('logic')
-    def logic_validate_enum(cls, value):
-        """Validates the enum"""
-        if value is None:
-            return value
-
-        if value not in set(['And', 'Or', 'Not']):
-            raise ValueError("must be one of enum values ('And', 'Or', 'Not')")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/runs_by_leaderboard_result.py

@@ -18,8 +18,9 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
-from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
+from rapidata.api_client.models.run_status import RunStatus
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -29,19 +30,12 @@ class RunsByLeaderboardResult(BaseModel):
     """ # noqa: E501
     id: StrictStr
     name: StrictStr
-    status: StrictStr
+    status: RunStatus
     created_at: datetime = Field(alias="createdAt")
     owner_mail: StrictStr = Field(alias="ownerMail")
     order_id: Optional[StrictStr] = Field(default=None, alias="orderId")
     __properties: ClassVar[List[str]] = ["id", "name", "status", "createdAt", "ownerMail", "orderId"]
 
-    @field_validator('status')
-    def status_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Queued', 'Running', 'Completed', 'Failed']):
-            raise ValueError("must be one of enum values ('Queued', 'Running', 'Completed', 'Failed')")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/simple_workflow_config.py

@@ -18,8 +18,9 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from rapidata.api_client.models.compare_workflow_model1_referee import CompareWorkflowModel1Referee
+from rapidata.api_client.models.feature_flag import FeatureFlag
 from rapidata.api_client.models.validation_set_zip_post_request_blueprint import ValidationSetZipPostRequestBlueprint
 from typing import Optional, Set
 from typing_extensions import Self
@@ -31,7 +32,8 @@ class SimpleWorkflowConfig(BaseModel):
     t: StrictStr = Field(description="Discriminator value for SimpleWorkflowConfig", alias="_t")
     referee: CompareWorkflowModel1Referee
     blueprint: ValidationSetZipPostRequestBlueprint
-    __properties: ClassVar[List[str]] = ["_t", "referee", "blueprint"]
+    feature_flags: Optional[List[FeatureFlag]] = Field(default=None, alias="featureFlags")
+    __properties: ClassVar[List[str]] = ["_t", "referee", "blueprint", "featureFlags"]
 
     @field_validator('t')
     def t_validate_enum(cls, value):
@@ -85,6 +87,13 @@ class SimpleWorkflowConfig(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of blueprint
         if self.blueprint:
             _dict['blueprint'] = self.blueprint.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in feature_flags (list)
+        _items = []
+        if self.feature_flags:
+            for _item_feature_flags in self.feature_flags:
+                if _item_feature_flags:
+                    _items.append(_item_feature_flags.to_dict())
+            _dict['featureFlags'] = _items
         return _dict
 
     @classmethod
@@ -99,7 +108,8 @@ class SimpleWorkflowConfig(BaseModel):
         _obj = cls.model_validate({
             "_t": obj.get("_t") if obj.get("_t") is not None else 'SimpleWorkflowConfig',
             "referee": CompareWorkflowModel1Referee.from_dict(obj["referee"]) if obj.get("referee") is not None else None,
-            "blueprint": ValidationSetZipPostRequestBlueprint.from_dict(obj["blueprint"]) if obj.get("blueprint") is not None else None
+            "blueprint": ValidationSetZipPostRequestBlueprint.from_dict(obj["blueprint"]) if obj.get("blueprint") is not None else None,
+            "featureFlags": [FeatureFlag.from_dict(_item) for _item in obj["featureFlags"]] if obj.get("featureFlags") is not None else None
         })
         return _obj
 

rapidata/api_client/models/simple_workflow_config_model.py

@@ -20,6 +20,7 @@ import json
 from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List
 from rapidata.api_client.models.compare_workflow_model1_referee import CompareWorkflowModel1Referee
+from rapidata.api_client.models.feature_flag import FeatureFlag
 from rapidata.api_client.models.simple_workflow_config_model_blueprint import SimpleWorkflowConfigModelBlueprint
 from typing import Optional, Set
 from typing_extensions import Self
@@ -31,8 +32,8 @@ class SimpleWorkflowConfigModel(BaseModel):
     t: StrictStr = Field(description="Discriminator value for SimpleWorkflowConfig", alias="_t")
     referee: CompareWorkflowModel1Referee
     blueprint: SimpleWorkflowConfigModelBlueprint
-    target_country_codes: List[StrictStr] = Field(description="A list of country codes that this workflow is targeting.", alias="targetCountryCodes")
-    __properties: ClassVar[List[str]] = ["_t", "referee", "blueprint", "targetCountryCodes"]
+    feature_flags: List[FeatureFlag] = Field(description="The list of feature flags that will be applied to the rapids created by this workflow.", alias="featureFlags")
+    __properties: ClassVar[List[str]] = ["_t", "referee", "blueprint", "featureFlags"]
 
     @field_validator('t')
     def t_validate_enum(cls, value):
@@ -86,6 +87,13 @@ class SimpleWorkflowConfigModel(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of blueprint
         if self.blueprint:
             _dict['blueprint'] = self.blueprint.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in feature_flags (list)
+        _items = []
+        if self.feature_flags:
+            for _item_feature_flags in self.feature_flags:
+                if _item_feature_flags:
+                    _items.append(_item_feature_flags.to_dict())
+            _dict['featureFlags'] = _items
         return _dict
 
     @classmethod
@@ -101,7 +109,7 @@ class SimpleWorkflowConfigModel(BaseModel):
             "_t": obj.get("_t") if obj.get("_t") is not None else 'SimpleWorkflowConfig',
             "referee": CompareWorkflowModel1Referee.from_dict(obj["referee"]) if obj.get("referee") is not None else None,
             "blueprint": SimpleWorkflowConfigModelBlueprint.from_dict(obj["blueprint"]) if obj.get("blueprint") is not None else None,
-            "targetCountryCodes": obj.get("targetCountryCodes")
+            "featureFlags": [FeatureFlag.from_dict(_item) for _item in obj["featureFlags"]] if obj.get("featureFlags") is not None else None
         })
         return _obj
 

rapidata/api_client/models/simple_workflow_model.py

@@ -18,7 +18,8 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
+from rapidata.api_client.models.feature_flag import FeatureFlag
 from rapidata.api_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
 from typing import Optional, Set
 from typing_extensions import Self
@@ -29,7 +30,8 @@ class SimpleWorkflowModel(BaseModel):
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for SimpleWorkflow", alias="_t")
     blueprint: SimpleWorkflowModelBlueprint
-    __properties: ClassVar[List[str]] = ["_t", "blueprint"]
+    feature_flags: Optional[List[FeatureFlag]] = Field(default=None, description="The list of feature flags that will be applied to the rapids created by this workflow.", alias="featureFlags")
+    __properties: ClassVar[List[str]] = ["_t", "blueprint", "featureFlags"]
 
     @field_validator('t')
     def t_validate_enum(cls, value):
@@ -80,6 +82,13 @@ class SimpleWorkflowModel(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of blueprint
         if self.blueprint:
             _dict['blueprint'] = self.blueprint.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in feature_flags (list)
+        _items = []
+        if self.feature_flags:
+            for _item_feature_flags in self.feature_flags:
+                if _item_feature_flags:
+                    _items.append(_item_feature_flags.to_dict())
+            _dict['featureFlags'] = _items
         return _dict
 
     @classmethod
@@ -93,7 +102,8 @@ class SimpleWorkflowModel(BaseModel):
 
         _obj = cls.model_validate({
             "_t": obj.get("_t") if obj.get("_t") is not None else 'SimpleWorkflow',
-            "blueprint": SimpleWorkflowModelBlueprint.from_dict(obj["blueprint"]) if obj.get("blueprint") is not None else None
+            "blueprint": SimpleWorkflowModelBlueprint.from_dict(obj["blueprint"]) if obj.get("blueprint") is not None else None,
+            "featureFlags": [FeatureFlag.from_dict(_item) for _item in obj["featureFlags"]] if obj.get("featureFlags") is not None else None
         })
         return _obj
 

rapidata/api_client/models/sort_criterion.py

@@ -17,8 +17,9 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
 from typing import Any, ClassVar, Dict, List
+from rapidata.api_client.models.sort_direction import SortDirection
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -27,16 +28,9 @@ class SortCriterion(BaseModel):
     SortCriterion
     """ # noqa: E501
     property_name: StrictStr = Field(alias="propertyName")
-    direction: StrictStr
+    direction: SortDirection
     __properties: ClassVar[List[str]] = ["propertyName", "direction"]
 
-    @field_validator('direction')
-    def direction_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Asc', 'Desc']):
-            raise ValueError("must be one of enum values ('Asc', 'Desc')")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,