qanswer_sdk 3.1213.0__py3-none-any.whl → 3.1245.0__py3-none-any.whl

qanswer_sdk/models/socket_file_metadata.py

@@ -19,8 +19,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional, Union
-from qanswer_sdk.models.json_nullable_file_failure_reason import JsonNullableFileFailureReason
-from qanswer_sdk.models.json_nullable_source_metadata import JsonNullableSourceMetadata
+from qanswer_sdk.models.source_metadata import SourceMetadata
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -45,7 +44,7 @@ class SocketFileMetadata(BaseModel):
     category: Optional[StrictStr] = None
     comments: Optional[StrictStr] = None
     keywords: Optional[StrictStr] = None
-    source_metadata: Optional[JsonNullableSourceMetadata] = None
+    source_metadata: Optional[SourceMetadata] = None
     username: StrictStr = Field(description="Username of the dataset")
     dataset: StrictStr = Field(description="Name of the dataset")
     connector_id: StrictInt
@@ -53,7 +52,7 @@ class SocketFileMetadata(BaseModel):
     connector_type: StrictStr
     usage: Optional[StrictInt] = None
     status: StrictStr
-    failure_reason: Optional[JsonNullableFileFailureReason] = None
+    failure_reason: Optional[StrictStr] = None
     source: StrictStr
     source_type: Optional[StrictStr] = None
     weight: Optional[Union[StrictFloat, StrictInt]] = None
@@ -70,8 +69,18 @@ class SocketFileMetadata(BaseModel):
     @field_validator('status')
     def status_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in set(['Submitted', 'Uploaded', 'Converted', 'Indexed', 'QuotaExceeded', 'Failed', 'MalwareDetected']):
-            raise ValueError("must be one of enum values ('Submitted', 'Uploaded', 'Converted', 'Indexed', 'QuotaExceeded', 'Failed', 'MalwareDetected')")
+        if value not in set(['Submitted', 'Uploaded', 'Converted', 'Indexed', 'QuotaExceeded', 'Failed', 'MalwareDetected', 'NeedsToBeUploaded']):
+            raise ValueError("must be one of enum values ('Submitted', 'Uploaded', 'Converted', 'Indexed', 'QuotaExceeded', 'Failed', 'MalwareDetected', 'NeedsToBeUploaded')")
+        return value
+
+    @field_validator('failure_reason')
+    def failure_reason_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['format_not_supported', 'file_empty', 'pdf_conversion_failed', 'embedding_failed', 'indexing_failed', 'quota_exceeded', 'illegal_filename', 'malware_detected', 'duplicate_filename', 'unknown_error', 'website_not_reachable', 'remote_file_rejected', 'other']):
+            raise ValueError("must be one of enum values ('format_not_supported', 'file_empty', 'pdf_conversion_failed', 'embedding_failed', 'indexing_failed', 'quota_exceeded', 'illegal_filename', 'malware_detected', 'duplicate_filename', 'unknown_error', 'website_not_reachable', 'remote_file_rejected', 'other')")
         return value
 
     model_config = ConfigDict(
@@ -116,9 +125,6 @@ class SocketFileMetadata(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of source_metadata
         if self.source_metadata:
             _dict['source_metadata'] = self.source_metadata.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of failure_reason
-        if self.failure_reason:
-            _dict['failure_reason'] = self.failure_reason.to_dict()
         return _dict
 
     @classmethod
@@ -148,7 +154,7 @@ class SocketFileMetadata(BaseModel):
             "category": obj.get("category"),
             "comments": obj.get("comments"),
             "keywords": obj.get("keywords"),
-            "source_metadata": JsonNullableSourceMetadata.from_dict(obj["source_metadata"]) if obj.get("source_metadata") is not None else None,
+            "source_metadata": SourceMetadata.from_dict(obj["source_metadata"]) if obj.get("source_metadata") is not None else None,
             "username": obj.get("username"),
             "dataset": obj.get("dataset"),
             "connector_id": obj.get("connector_id"),
@@ -156,7 +162,7 @@ class SocketFileMetadata(BaseModel):
             "connector_type": obj.get("connector_type"),
             "usage": obj.get("usage"),
             "status": obj.get("status"),
-            "failure_reason": JsonNullableFileFailureReason.from_dict(obj["failure_reason"]) if obj.get("failure_reason") is not None else None,
+            "failure_reason": obj.get("failure_reason"),
             "source": obj.get("source"),
             "source_type": obj.get("source_type"),
             "weight": obj.get("weight"),

qanswer_sdk/models/source_metadata.py

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+"""
+    QAnswer: Api Documentation
+
+    APIs provided by QAnswer
+
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SourceMetadata(BaseModel):
+    """
+    SourceMetadata
+    """ # noqa: E501
+    created_date_time: Optional[StrictStr] = Field(default=None, alias="createdDateTime")
+    last_modified_date_time: Optional[StrictStr] = Field(default=None, alias="lastModifiedDateTime")
+    id: Optional[StrictStr] = None
+    name: Optional[StrictStr] = None
+    size: Optional[StrictInt] = None
+    web_url: Optional[StrictStr] = Field(default=None, alias="webUrl")
+    display_name: Optional[StrictStr] = Field(default=None, alias="displayName")
+    parent_reference: Optional[Dict[str, Any]] = Field(default=None, alias="parentReference")
+    site_id: Optional[StrictStr] = None
+    drive_id: Optional[StrictStr] = None
+    path: Optional[StrictStr] = None
+    file_type: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["createdDateTime", "lastModifiedDateTime", "id", "name", "size", "webUrl", "displayName", "parentReference", "site_id", "drive_id", "path", "file_type"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SourceMetadata from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SourceMetadata from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "createdDateTime": obj.get("createdDateTime"),
+            "lastModifiedDateTime": obj.get("lastModifiedDateTime"),
+            "id": obj.get("id"),
+            "name": obj.get("name"),
+            "size": obj.get("size"),
+            "webUrl": obj.get("webUrl"),
+            "displayName": obj.get("displayName"),
+            "parentReference": obj.get("parentReference"),
+            "site_id": obj.get("site_id"),
+            "drive_id": obj.get("drive_id"),
+            "path": obj.get("path"),
+            "file_type": obj.get("file_type")
+        })
+        return _obj
+
+

qanswer_sdk/models/{tag_qa_list_payload.py → subscription_response.py}

@@ -17,18 +17,29 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictBool
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
-class TagQAListPayload(BaseModel):
+class SubscriptionResponse(BaseModel):
     """
-    TagQAListPayload
+    SubscriptionResponse
     """ # noqa: E501
-    empty: Optional[StrictBool] = None
-    additional_properties: Dict[str, Any] = {}
-    __properties: ClassVar[List[str]] = ["empty"]
+    success: Optional[StrictBool] = None
+    status: Optional[StrictStr] = None
+    message: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["success", "status", "message"]
+
+    @field_validator('status')
+    def status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['CREATED', 'UPDATED', 'CANCELLED', 'FAILED']):
+            raise ValueError("must be one of enum values ('CREATED', 'UPDATED', 'CANCELLED', 'FAILED')")
+        return value
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -48,7 +59,7 @@ class TagQAListPayload(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of TagQAListPayload from a JSON string"""
+        """Create an instance of SubscriptionResponse from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -60,10 +71,8 @@ class TagQAListPayload(BaseModel):
         * `None` is only added to the output dict for nullable fields that
           were set at model initialization. Other fields with value `None`
           are ignored.
-        * Fields in `self.additional_properties` are added to the output dict.
         """
         excluded_fields: Set[str] = set([
-            "additional_properties",
         ])
 
         _dict = self.model_dump(
@@ -71,16 +80,11 @@ class TagQAListPayload(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # puts key-value pairs in additional_properties in the top level
-        if self.additional_properties is not None:
-            for _key, _value in self.additional_properties.items():
-                _dict[_key] = _value
-
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of TagQAListPayload from a dict"""
+        """Create an instance of SubscriptionResponse from a dict"""
         if obj is None:
             return None
 
@@ -88,13 +92,10 @@ class TagQAListPayload(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "empty": obj.get("empty")
+            "success": obj.get("success"),
+            "status": obj.get("status"),
+            "message": obj.get("message")
         })
-        # store additional fields in additional_properties
-        for _key in obj.keys():
-            if _key not in cls.__properties:
-                _obj.additional_properties[_key] = obj.get(_key)
-
         return _obj
 
 

qanswer_sdk/models/{team_with_count.py → team_admin.py}

@@ -17,21 +17,21 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
-class TeamWithCount(BaseModel):
+class TeamAdmin(BaseModel):
     """
-    Represents a team within an organization with the head count.
+    Represents a team within an organization and the role.
     """ # noqa: E501
     name: Optional[StrictStr] = Field(default=None, description="Team Name")
     description: Optional[StrictStr] = Field(default=None, description="Brief explanation of the team's purpose.")
     id: Optional[StrictInt] = Field(default=None, description="Unique identifier")
     organization_id: Optional[StrictInt] = Field(default=None, description="Unique identifier of the organization", alias="organizationId")
-    number_of_members: Optional[StrictInt] = Field(default=None, description="Number of members in the team", alias="numberOfMembers")
-    __properties: ClassVar[List[str]] = ["name", "description", "id", "organizationId", "numberOfMembers"]
+    admin: Optional[StrictBool] = Field(default=None, description="Indicates if the user is an admin or not")
+    __properties: ClassVar[List[str]] = ["name", "description", "id", "organizationId", "admin"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -51,7 +51,7 @@ class TeamWithCount(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of TeamWithCount from a JSON string"""
+        """Create an instance of TeamAdmin from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -76,7 +76,7 @@ class TeamWithCount(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of TeamWithCount from a dict"""
+        """Create an instance of TeamAdmin from a dict"""
         if obj is None:
             return None
 
@@ -88,7 +88,7 @@ class TeamWithCount(BaseModel):
             "description": obj.get("description"),
             "id": obj.get("id"),
             "organizationId": obj.get("organizationId"),
-            "numberOfMembers": obj.get("numberOfMembers")
+            "admin": obj.get("admin")
         })
         return _obj
 

qanswer_sdk/models/{team_filter.py → team_filter_dto.py}

@@ -22,14 +22,19 @@ from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
-class TeamFilter(BaseModel):
+class TeamFilterDto(BaseModel):
     """
-    TeamFilter
+    TeamFilterDto
     """ # noqa: E501
     search: Optional[StrictStr] = Field(default='The QA Company', description="Search to filter over the team name")
     organization_id: Optional[StrictInt] = Field(default=None, description="Search to filter over the organizationId", alias="organizationId")
     team_id: Optional[StrictInt] = Field(default=None, description="Search to filter over the organizationId", alias="teamId")
-    __properties: ClassVar[List[str]] = ["search", "organizationId", "teamId"]
+    user_id: Optional[StrictInt] = Field(default=None, description="The user id to filter over the teams the user is a member of", alias="userId")
+    page: Optional[StrictInt] = None
+    size: Optional[StrictInt] = None
+    sort_by: Optional[StrictStr] = Field(default=None, alias="sortBy")
+    sort_dir: Optional[StrictStr] = Field(default=None, alias="sortDir")
+    __properties: ClassVar[List[str]] = ["search", "organizationId", "teamId", "userId", "page", "size", "sortBy", "sortDir"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -49,7 +54,7 @@ class TeamFilter(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of TeamFilter from a JSON string"""
+        """Create an instance of TeamFilterDto from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -74,7 +79,7 @@ class TeamFilter(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of TeamFilter from a dict"""
+        """Create an instance of TeamFilterDto from a dict"""
         if obj is None:
             return None
 
@@ -84,7 +89,12 @@ class TeamFilter(BaseModel):
         _obj = cls.model_validate({
             "search": obj.get("search") if obj.get("search") is not None else 'The QA Company',
             "organizationId": obj.get("organizationId"),
-            "teamId": obj.get("teamId")
+            "teamId": obj.get("teamId"),
+            "userId": obj.get("userId"),
+            "page": obj.get("page"),
+            "size": obj.get("size"),
+            "sortBy": obj.get("sortBy"),
+            "sortDir": obj.get("sortDir")
         })
         return _obj
 

qanswer_sdk/models/team_list_dto.py

@@ -0,0 +1,101 @@
+# coding: utf-8
+
+"""
+    QAnswer: Api Documentation
+
+    APIs provided by QAnswer
+
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from qanswer_sdk.models.team import Team
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TeamListDto(BaseModel):
+    """
+    TeamListDto
+    """ # noqa: E501
+    teams: Optional[List[Team]] = None
+    page: Optional[StrictInt] = None
+    page_size: Optional[StrictInt] = Field(default=None, alias="pageSize")
+    total: Optional[StrictInt] = None
+    __properties: ClassVar[List[str]] = ["teams", "page", "pageSize", "total"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of TeamListDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in teams (list)
+        _items = []
+        if self.teams:
+            for _item_teams in self.teams:
+                if _item_teams:
+                    _items.append(_item_teams.to_dict())
+            _dict['teams'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TeamListDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "teams": [Team.from_dict(_item) for _item in obj["teams"]] if obj.get("teams") is not None else None,
+            "page": obj.get("page"),
+            "pageSize": obj.get("pageSize"),
+            "total": obj.get("total")
+        })
+        return _obj
+
+

qanswer_sdk/models/{available_endpoints_response.py → template_clip_structure_input.py}

@@ -19,16 +19,16 @@ import json
 
 from pydantic import BaseModel, ConfigDict
 from typing import Any, ClassVar, Dict, List
-from qanswer_sdk.models.llm_details import LLMDetails
+from qanswer_sdk.models.clip_connector_structure import ClipConnectorStructure
 from typing import Optional, Set
 from typing_extensions import Self
 
-class AvailableEndpointsResponse(BaseModel):
+class TemplateClipStructureInput(BaseModel):
     """
-    AvailableEndpointsResponse
+    TemplateClipStructureInput
     """ # noqa: E501
-    options: List[LLMDetails]
-    __properties: ClassVar[List[str]] = ["options"]
+    connectors: List[ClipConnectorStructure]
+    __properties: ClassVar[List[str]] = ["connectors"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -48,7 +48,7 @@ class AvailableEndpointsResponse(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of AvailableEndpointsResponse from a JSON string"""
+        """Create an instance of TemplateClipStructureInput from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -69,18 +69,18 @@ class AvailableEndpointsResponse(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of each item in options (list)
+        # override the default output from pydantic by calling `to_dict()` of each item in connectors (list)
         _items = []
-        if self.options:
-            for _item_options in self.options:
-                if _item_options:
-                    _items.append(_item_options.to_dict())
-            _dict['options'] = _items
+        if self.connectors:
+            for _item_connectors in self.connectors:
+                if _item_connectors:
+                    _items.append(_item_connectors.to_dict())
+            _dict['connectors'] = _items
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of AvailableEndpointsResponse from a dict"""
+        """Create an instance of TemplateClipStructureInput from a dict"""
         if obj is None:
             return None
 
@@ -88,7 +88,7 @@ class AvailableEndpointsResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "options": [LLMDetails.from_dict(_item) for _item in obj["options"]] if obj.get("options") is not None else None
+            "connectors": [ClipConnectorStructure.from_dict(_item) for _item in obj["connectors"]] if obj.get("connectors") is not None else None
         })
         return _obj
 

qanswer_sdk/models/{available_embedding_models_response.py → template_clip_structure_output.py}

@@ -19,16 +19,16 @@ import json
 
 from pydantic import BaseModel, ConfigDict
 from typing import Any, ClassVar, Dict, List
-from qanswer_sdk.models.embedding_model import EmbeddingModel
+from qanswer_sdk.models.clip_connector_structure import ClipConnectorStructure
 from typing import Optional, Set
 from typing_extensions import Self
 
-class AvailableEmbeddingModelsResponse(BaseModel):
+class TemplateClipStructureOutput(BaseModel):
     """
-    AvailableEmbeddingModelsResponse
+    TemplateClipStructureOutput
     """ # noqa: E501
-    options: List[EmbeddingModel]
-    __properties: ClassVar[List[str]] = ["options"]
+    connectors: List[ClipConnectorStructure]
+    __properties: ClassVar[List[str]] = ["connectors"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -48,7 +48,7 @@ class AvailableEmbeddingModelsResponse(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of AvailableEmbeddingModelsResponse from a JSON string"""
+        """Create an instance of TemplateClipStructureOutput from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -69,18 +69,18 @@ class AvailableEmbeddingModelsResponse(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of each item in options (list)
+        # override the default output from pydantic by calling `to_dict()` of each item in connectors (list)
         _items = []
-        if self.options:
-            for _item_options in self.options:
-                if _item_options:
-                    _items.append(_item_options.to_dict())
-            _dict['options'] = _items
+        if self.connectors:
+            for _item_connectors in self.connectors:
+                if _item_connectors:
+                    _items.append(_item_connectors.to_dict())
+            _dict['connectors'] = _items
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of AvailableEmbeddingModelsResponse from a dict"""
+        """Create an instance of TemplateClipStructureOutput from a dict"""
         if obj is None:
             return None
 
@@ -88,7 +88,7 @@ class AvailableEmbeddingModelsResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "options": [EmbeddingModel.from_dict(_item) for _item in obj["options"]] if obj.get("options") is not None else None
+            "connectors": [ClipConnectorStructure.from_dict(_item) for _item in obj["connectors"]] if obj.get("connectors") is not None else None
         })
         return _obj