amazon-creatorsapi-python-sdk 1.0.0__py3-none-any.whl

creatorsapi_python_sdk/models/search_items_request_content.py

@@ -0,0 +1,242 @@
+# coding: utf-8
+
+"""
+Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License").
+You may not use this file except in compliance with the License.
+A copy of the License is located at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+or in the "license" file accompanying this file. This file is distributed
+on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+
+"""  # noqa: E501
+
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from creatorsapi_python_sdk.models.availability import Availability
+from creatorsapi_python_sdk.models.condition import Condition
+from creatorsapi_python_sdk.models.delivery_flag import DeliveryFlag
+from creatorsapi_python_sdk.models.search_items_resource import SearchItemsResource
+from creatorsapi_python_sdk.models.sort_by import SortBy
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SearchItemsRequestContent(BaseModel):
+    """
+    The request object for the search items operation. It contains the request parameters for the search items operation.
+    """ # noqa: E501
+    actor: Optional[Annotated[str, Field(strict=True, max_length=1000)]] = Field(default=None, description="Actor name associated with the item. You can enter all or part of the name.")
+    artist: Optional[Annotated[str, Field(strict=True, max_length=1000)]] = Field(default=None, description="Artist name associated with the item. You can enter all or part of the name.")
+    author: Optional[Annotated[str, Field(strict=True, max_length=1000)]] = Field(default=None, description="Author name associated with the item. You can enter all or part of the name.")
+    availability: Optional[Availability] = None
+    brand: Optional[Annotated[str, Field(strict=True, max_length=1000)]] = Field(default=None, description="Brand name associated with the item. You can enter all or part of the name.")
+    browse_node_id: Optional[Annotated[str, Field(strict=True, max_length=19)]] = Field(default=None, description="A unique ID assigned by Amazon that identifies a product category/sub-category. The BrowseNodeId is a positive Long having max value upto Long.MAX_VALUE i.e. 9223372036854775807 (inclusive).", alias="browseNodeId")
+    condition: Optional[Condition] = None
+    currency_of_preference: Optional[Annotated[str, Field(strict=True, max_length=100)]] = Field(default=None, description="Currency of preference in which the prices information should be returned in response. By default the prices are returned in the default currency of the marketplace. Expected currency code format is the ISO 4217 currency code (i.e. USD, EUR etc.).", alias="currencyOfPreference")
+    delivery_flags: Optional[Annotated[List[DeliveryFlag], Field(max_length=100)]] = Field(default=None, description="List of DeliveryFlag which denotes a certain delivery program.", alias="deliveryFlags")
+    item_count: Optional[Union[Annotated[float, Field(le=100, strict=True, ge=1)], Annotated[int, Field(le=100, strict=True, ge=1)]]] = Field(default=None, description="The number of items desired in SearchItems response.", alias="itemCount")
+    item_page: Optional[Union[Annotated[float, Field(le=10, strict=True, ge=1)], Annotated[int, Field(le=10, strict=True, ge=1)]]] = Field(default=None, description="The specific page of items to be returned from the available Search Results.", alias="itemPage")
+    keywords: Optional[Annotated[str, Field(strict=True, max_length=1000)]] = Field(default=None, description="A word or phrase that describes an item i.e. the search query.")
+    languages_of_preference: Optional[Annotated[List[Annotated[str, Field(strict=True, max_length=1000)]], Field(max_length=1)]] = Field(default=None, description="Languages in order of preference in which the item information should be returned in response. By default the item information is returned in the default language of the marketplace.", alias="languagesOfPreference")
+    max_price: Optional[Union[Annotated[float, Field(strict=True, ge=1)], Annotated[int, Field(strict=True, ge=1)]]] = Field(default=None, description="The MaxPrice parameter filters search results to items with at least one offer price below the specified value.", alias="maxPrice")
+    min_price: Optional[Union[Annotated[float, Field(strict=True, ge=1)], Annotated[int, Field(strict=True, ge=1)]]] = Field(default=None, description="The MinPrice parameter filters search results to items with at least one offer price above the specified value.", alias="minPrice")
+    min_reviews_rating: Optional[Union[Annotated[float, Field(le=4, strict=True, ge=1)], Annotated[int, Field(le=4, strict=True, ge=1)]]] = Field(default=None, description="The MinReviewsRating parameter filters search results to items with customer review ratings above specified value.", alias="minReviewsRating")
+    min_saving_percent: Optional[Union[Annotated[float, Field(le=99, strict=True, ge=1)], Annotated[int, Field(le=99, strict=True, ge=1)]]] = Field(default=None, description="The MinSavingPercent parameter filters search results to items with at least one offer having saving percentage above the specified value.", alias="minSavingPercent")
+    partner_tag: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="An alphanumeric token that uniquely identifies a partner. If the value of PartnerType is Associates, enter your Store Id or tracking ID.", alias="partnerTag")
+    properties: Optional[Dict[str, Annotated[str, Field(strict=True)]]] = Field(default=None, description="Reserved parameter for specifying key-value pairs. This is a flexible mechanism for passing additional context or metadata to the API.")
+    resources: Optional[Annotated[List[SearchItemsResource], Field(max_length=100)]] = Field(default=None, description="List of resources for SearchItems operation which specify the values to return.")
+    search_index: Optional[Annotated[str, Field(strict=True, max_length=1000)]] = Field(default=None, description="Indicates the product category to search. SearchIndex values differ by marketplace.", alias="searchIndex")
+    sort_by: Optional[SortBy] = Field(default=None, alias="sortBy")
+    title: Optional[Annotated[str, Field(strict=True, max_length=1000)]] = Field(default=None, description="Title associated with the item.")
+    __properties: ClassVar[List[str]] = ["actor", "artist", "author", "availability", "brand", "browseNodeId", "condition", "currencyOfPreference", "deliveryFlags", "itemCount", "itemPage", "keywords", "languagesOfPreference", "maxPrice", "minPrice", "minReviewsRating", "minSavingPercent", "partnerTag", "properties", "resources", "searchIndex", "sortBy", "title"]
+
+    @field_validator('actor')
+    def actor_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r".*\S.*", value):
+            raise ValueError(r"must validate the regular expression /.*\S.*/")
+        return value
+
+    @field_validator('artist')
+    def artist_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r".*\S.*", value):
+            raise ValueError(r"must validate the regular expression /.*\S.*/")
+        return value
+
+    @field_validator('author')
+    def author_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r".*\S.*", value):
+            raise ValueError(r"must validate the regular expression /.*\S.*/")
+        return value
+
+    @field_validator('brand')
+    def brand_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r".*\S.*", value):
+            raise ValueError(r"must validate the regular expression /.*\S.*/")
+        return value
+
+    @field_validator('browse_node_id')
+    def browse_node_id_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[1-9][0-9]*$", value):
+            raise ValueError(r"must validate the regular expression /^[1-9][0-9]*$/")
+        return value
+
+    @field_validator('currency_of_preference')
+    def currency_of_preference_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r".*\S.*", value):
+            raise ValueError(r"must validate the regular expression /.*\S.*/")
+        return value
+
+    @field_validator('keywords')
+    def keywords_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r".*\S.*", value):
+            raise ValueError(r"must validate the regular expression /.*\S.*/")
+        return value
+
+    @field_validator('partner_tag')
+    def partner_tag_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r".*\S.*", value):
+            raise ValueError(r"must validate the regular expression /.*\S.*/")
+        return value
+
+    @field_validator('search_index')
+    def search_index_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r".*\S.*", value):
+            raise ValueError(r"must validate the regular expression /.*\S.*/")
+        return value
+
+    @field_validator('title')
+    def title_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r".*\S.*", value):
+            raise ValueError(r"must validate the regular expression /.*\S.*/")
+        return value
+
+    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"""
+        return self.model_dump_json(by_alias=True, exclude_unset=True)
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SearchItemsRequestContent 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 SearchItemsRequestContent from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "actor": obj.get("actor"),
+            "artist": obj.get("artist"),
+            "author": obj.get("author"),
+            "availability": obj.get("availability"),
+            "brand": obj.get("brand"),
+            "browseNodeId": obj.get("browseNodeId"),
+            "condition": obj.get("condition"),
+            "currencyOfPreference": obj.get("currencyOfPreference"),
+            "deliveryFlags": obj.get("deliveryFlags"),
+            "itemCount": obj.get("itemCount"),
+            "itemPage": obj.get("itemPage"),
+            "keywords": obj.get("keywords"),
+            "languagesOfPreference": obj.get("languagesOfPreference"),
+            "maxPrice": obj.get("maxPrice"),
+            "minPrice": obj.get("minPrice"),
+            "minReviewsRating": obj.get("minReviewsRating"),
+            "minSavingPercent": obj.get("minSavingPercent"),
+            "partnerTag": obj.get("partnerTag"),
+            "properties": obj.get("properties"),
+            "resources": obj.get("resources"),
+            "searchIndex": obj.get("searchIndex"),
+            "sortBy": obj.get("sortBy"),
+            "title": obj.get("title")
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/search_items_resource.py

@@ -0,0 +1,77 @@
+# coding: utf-8
+
+"""
+Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License").
+You may not use this file except in compliance with the License.
+A copy of the License is located at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+or in the "license" file accompanying this file. This file is distributed
+on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+
+"""  # noqa: E501
+
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class SearchItemsResource(str, Enum):
+    """
+    SearchItemsResource
+    """
+
+    """
+    allowed enum values
+    """
+    BROWSE_NODE_INFO_DOT_BROWSE_NODES = 'browseNodeInfo.browseNodes'
+    BROWSE_NODE_INFO_DOT_BROWSE_NODES_DOT_ANCESTOR = 'browseNodeInfo.browseNodes.ancestor'
+    BROWSE_NODE_INFO_DOT_BROWSE_NODES_DOT_SALES_RANK = 'browseNodeInfo.browseNodes.salesRank'
+    BROWSE_NODE_INFO_DOT_WEBSITE_SALES_RANK = 'browseNodeInfo.websiteSalesRank'
+    CUSTOMER_REVIEWS_DOT_COUNT = 'customerReviews.count'
+    CUSTOMER_REVIEWS_DOT_STAR_RATING = 'customerReviews.starRating'
+    IMAGES_DOT_PRIMARY_DOT_SMALL = 'images.primary.small'
+    IMAGES_DOT_PRIMARY_DOT_MEDIUM = 'images.primary.medium'
+    IMAGES_DOT_PRIMARY_DOT_LARGE = 'images.primary.large'
+    IMAGES_DOT_PRIMARY_DOT_HIGH_RES = 'images.primary.highRes'
+    IMAGES_DOT_VARIANTS_DOT_SMALL = 'images.variants.small'
+    IMAGES_DOT_VARIANTS_DOT_MEDIUM = 'images.variants.medium'
+    IMAGES_DOT_VARIANTS_DOT_LARGE = 'images.variants.large'
+    IMAGES_DOT_VARIANTS_DOT_HIGH_RES = 'images.variants.highRes'
+    ITEM_INFO_DOT_BY_LINE_INFO = 'itemInfo.byLineInfo'
+    ITEM_INFO_DOT_CONTENT_INFO = 'itemInfo.contentInfo'
+    ITEM_INFO_DOT_CONTENT_RATING = 'itemInfo.contentRating'
+    ITEM_INFO_DOT_CLASSIFICATIONS = 'itemInfo.classifications'
+    ITEM_INFO_DOT_EXTERNAL_IDS = 'itemInfo.externalIds'
+    ITEM_INFO_DOT_FEATURES = 'itemInfo.features'
+    ITEM_INFO_DOT_MANUFACTURE_INFO = 'itemInfo.manufactureInfo'
+    ITEM_INFO_DOT_PRODUCT_INFO = 'itemInfo.productInfo'
+    ITEM_INFO_DOT_TECHNICAL_INFO = 'itemInfo.technicalInfo'
+    ITEM_INFO_DOT_TITLE = 'itemInfo.title'
+    ITEM_INFO_DOT_TRADE_IN_INFO = 'itemInfo.tradeInInfo'
+    OFFERS_V2_DOT_LISTINGS_DOT_AVAILABILITY = 'offersV2.listings.availability'
+    OFFERS_V2_DOT_LISTINGS_DOT_CONDITION = 'offersV2.listings.condition'
+    OFFERS_V2_DOT_LISTINGS_DOT_DEAL_DETAILS = 'offersV2.listings.dealDetails'
+    OFFERS_V2_DOT_LISTINGS_DOT_IS_BUY_BOX_WINNER = 'offersV2.listings.isBuyBoxWinner'
+    OFFERS_V2_DOT_LISTINGS_DOT_LOYALTY_POINTS = 'offersV2.listings.loyaltyPoints'
+    OFFERS_V2_DOT_LISTINGS_DOT_MERCHANT_INFO = 'offersV2.listings.merchantInfo'
+    OFFERS_V2_DOT_LISTINGS_DOT_PRICE = 'offersV2.listings.price'
+    OFFERS_V2_DOT_LISTINGS_DOT_TYPE = 'offersV2.listings.type'
+    PARENTASIN = 'parentASIN'
+    SEARCHREFINEMENTS = 'searchRefinements'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of SearchItemsResource from a JSON string"""
+        return cls(json.loads(json_str))
+
+
+

creatorsapi_python_sdk/models/search_items_response_content.py

@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License").
+You may not use this file except in compliance with the License.
+A copy of the License is located at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+or in the "license" file accompanying this file. This file is distributed
+on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+
+"""  # noqa: E501
+
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from creatorsapi_python_sdk.models.error_data import ErrorData
+from creatorsapi_python_sdk.models.search_result import SearchResult
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SearchItemsResponseContent(BaseModel):
+    """
+    The response object for SearchItems operation.
+    """ # noqa: E501
+    search_result: Optional[SearchResult] = Field(default=None, alias="searchResult")
+    errors: Optional[List[ErrorData]] = Field(default=None, description="List of partial errors encountered during request processing in an otherwise successful response")
+    __properties: ClassVar[List[str]] = ["searchResult", "errors"]
+
+    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"""
+        return self.model_dump_json(by_alias=True, exclude_unset=True)
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SearchItemsResponseContent 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 search_result
+        if self.search_result:
+            _dict['searchResult'] = self.search_result.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in errors (list)
+        _items = []
+        if self.errors:
+            for _item_errors in self.errors:
+                if _item_errors:
+                    _items.append(_item_errors.to_dict())
+            _dict['errors'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SearchItemsResponseContent from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "searchResult": SearchResult.from_dict(obj["searchResult"]) if obj.get("searchResult") is not None else None,
+            "errors": [ErrorData.from_dict(_item) for _item in obj["errors"]] if obj.get("errors") is not None else None
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/search_refinements.py

@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License").
+You may not use this file except in compliance with the License.
+A copy of the License is located at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+or in the "license" file accompanying this file. This file is distributed
+on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+
+"""  # noqa: E501
+
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from creatorsapi_python_sdk.models.refinement import Refinement
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SearchRefinements(BaseModel):
+    """
+    Container for SearchRefinements resource which helps in filtering search results obtained from SearchItems operation. It contains relevant SearchIndexes, BrowseNodes and other dynamic refinements for a search request.
+    """ # noqa: E501
+    browse_node: Optional[Refinement] = Field(default=None, alias="browseNode")
+    other_refinements: Optional[List[Refinement]] = Field(default=None, description="List of refinements.", alias="otherRefinements")
+    search_index: Optional[Refinement] = Field(default=None, alias="searchIndex")
+    __properties: ClassVar[List[str]] = ["browseNode", "otherRefinements", "searchIndex"]
+
+    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"""
+        return self.model_dump_json(by_alias=True, exclude_unset=True)
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SearchRefinements 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 browse_node
+        if self.browse_node:
+            _dict['browseNode'] = self.browse_node.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in other_refinements (list)
+        _items = []
+        if self.other_refinements:
+            for _item_other_refinements in self.other_refinements:
+                if _item_other_refinements:
+                    _items.append(_item_other_refinements.to_dict())
+            _dict['otherRefinements'] = _items
+        # override the default output from pydantic by calling `to_dict()` of search_index
+        if self.search_index:
+            _dict['searchIndex'] = self.search_index.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SearchRefinements from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "browseNode": Refinement.from_dict(obj["browseNode"]) if obj.get("browseNode") is not None else None,
+            "otherRefinements": [Refinement.from_dict(_item) for _item in obj["otherRefinements"]] if obj.get("otherRefinements") is not None else None,
+            "searchIndex": Refinement.from_dict(obj["searchIndex"]) if obj.get("searchIndex") is not None else None
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/search_result.py

@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License").
+You may not use this file except in compliance with the License.
+A copy of the License is located at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+or in the "license" file accompanying this file. This file is distributed
+on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+
+"""  # noqa: E501
+
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from creatorsapi_python_sdk.models.item import Item
+from creatorsapi_python_sdk.models.search_refinements import SearchRefinements
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SearchResult(BaseModel):
+    """
+    The container for SearchItems response. It consists of search results items and some meta-data about the search result like TotalResultCount, SearchURL and SearchRefinements.
+    """ # noqa: E501
+    total_result_count: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="totalResultCount")
+    search_url: Optional[StrictStr] = Field(default=None, alias="searchURL")
+    items: Optional[List[Item]] = Field(default=None, description="List of Item which is a container for item information.")
+    search_refinements: Optional[SearchRefinements] = Field(default=None, alias="searchRefinements")
+    __properties: ClassVar[List[str]] = ["totalResultCount", "searchURL", "items", "searchRefinements"]
+
+    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"""
+        return self.model_dump_json(by_alias=True, exclude_unset=True)
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SearchResult 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 items (list)
+        _items = []
+        if self.items:
+            for _item_items in self.items:
+                if _item_items:
+                    _items.append(_item_items.to_dict())
+            _dict['items'] = _items
+        # override the default output from pydantic by calling `to_dict()` of search_refinements
+        if self.search_refinements:
+            _dict['searchRefinements'] = self.search_refinements.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SearchResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "totalResultCount": obj.get("totalResultCount"),
+            "searchURL": obj.get("searchURL"),
+            "items": [Item.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
+            "searchRefinements": SearchRefinements.from_dict(obj["searchRefinements"]) if obj.get("searchRefinements") is not None else None
+        })
+        return _obj
+
+