hyperstack 1.25.0a0__py3-none-any.whl → 1.41.0a0__py3-none-any.whl

hyperstack/models/{contract_billing_history.py → resource_level_billing_bucket_details_resources.py}

@@ -19,17 +19,17 @@ import json
 
 from pydantic import BaseModel, ConfigDict
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.contract_billing_history_response_attributes import ContractBillingHistoryResponseAttributes
-from ..models.contractl_billing_history_response_metrics import ContractlBillingHistoryResponseMetrics
+from ..models.resource_level_billing_details_attributes import ResourceLevelBillingDetailsAttributes
+from ..models.resource_level_billing_details_metrics import ResourceLevelBillingDetailsMetrics
 from typing import Optional, Set
 from typing_extensions import Self
 
-class ContractBillingHistory(BaseModel):
+class ResourceLevelBillingBucketDetailsResources(BaseModel):
     """
-    ContractBillingHistory
+    ResourceLevelBillingBucketDetailsResources
     """ # noqa: E501
-    attributes: Optional[ContractBillingHistoryResponseAttributes] = None
-    metrics: Optional[ContractlBillingHistoryResponseMetrics] = None
+    attributes: Optional[ResourceLevelBillingDetailsAttributes] = None
+    metrics: Optional[ResourceLevelBillingDetailsMetrics] = None
     __properties: ClassVar[List[str]] = ["attributes", "metrics"]
 
     model_config = ConfigDict(
@@ -50,7 +50,7 @@ class ContractBillingHistory(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of ContractBillingHistory from a JSON string"""
+        """Create an instance of ResourceLevelBillingBucketDetailsResources from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -81,7 +81,7 @@ class ContractBillingHistory(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of ContractBillingHistory from a dict"""
+        """Create an instance of ResourceLevelBillingBucketDetailsResources from a dict"""
         if obj is None:
             return None
 
@@ -89,8 +89,8 @@ class ContractBillingHistory(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "attributes": ContractBillingHistoryResponseAttributes.from_dict(obj["attributes"]) if obj.get("attributes") is not None else None,
-            "metrics": ContractlBillingHistoryResponseMetrics.from_dict(obj["metrics"]) if obj.get("metrics") is not None else None
+            "attributes": ResourceLevelBillingDetailsAttributes.from_dict(obj["attributes"]) if obj.get("attributes") is not None else None,
+            "metrics": ResourceLevelBillingDetailsMetrics.from_dict(obj["metrics"]) if obj.get("metrics") is not None else None
         })
         return _obj
 

hyperstack/models/{node_response_model.py → resource_level_billing_history_resources_cluster.py}

@@ -17,19 +17,22 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictStr
+from pydantic import BaseModel, ConfigDict
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.node_model import NodeModel
+from ..models.resource_level_billing_history_resources import ResourceLevelBillingHistoryResources
+from ..models.resource_level_billing_history_response_attributes import ResourceLevelBillingHistoryResponseAttributes
+from ..models.resource_level_billing_history_response_metrics import ResourceLevelBillingHistoryResponseMetrics
 from typing import Optional, Set
 from typing_extensions import Self
 
-class NodeResponseModel(BaseModel):
+class ResourceLevelBillingHistoryResourcesCluster(BaseModel):
     """
-    NodeResponseModel
+    ResourceLevelBillingHistoryResourcesCluster
     """ # noqa: E501
-    nodes: Optional[List[NodeModel]] = None
-    region: Optional[StrictStr] = None
-    __properties: ClassVar[List[str]] = ["nodes", "region"]
+    attributes: Optional[ResourceLevelBillingHistoryResponseAttributes] = None
+    metrics: Optional[ResourceLevelBillingHistoryResponseMetrics] = None
+    nodes: Optional[List[ResourceLevelBillingHistoryResources]] = None
+    __properties: ClassVar[List[str]] = ["attributes", "metrics", "nodes"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -49,7 +52,7 @@ class NodeResponseModel(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of NodeResponseModel from a JSON string"""
+        """Create an instance of ResourceLevelBillingHistoryResourcesCluster from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -70,6 +73,12 @@ class NodeResponseModel(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of attributes
+        if self.attributes:
+            _dict['attributes'] = self.attributes.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of metrics
+        if self.metrics:
+            _dict['metrics'] = self.metrics.to_dict()
         # override the default output from pydantic by calling `to_dict()` of each item in nodes (list)
         _items = []
         if self.nodes:
@@ -81,7 +90,7 @@ class NodeResponseModel(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of NodeResponseModel from a dict"""
+        """Create an instance of ResourceLevelBillingHistoryResourcesCluster from a dict"""
         if obj is None:
             return None
 
@@ -89,8 +98,9 @@ class NodeResponseModel(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "nodes": [NodeModel.from_dict(_item) for _item in obj["nodes"]] if obj.get("nodes") is not None else None,
-            "region": obj.get("region")
+            "attributes": ResourceLevelBillingHistoryResponseAttributes.from_dict(obj["attributes"]) if obj.get("attributes") is not None else None,
+            "metrics": ResourceLevelBillingHistoryResponseMetrics.from_dict(obj["metrics"]) if obj.get("metrics") is not None else None,
+            "nodes": [ResourceLevelBillingHistoryResources.from_dict(_item) for _item in obj["nodes"]] if obj.get("nodes") is not None else None
         })
         return _obj
 

hyperstack/models/resource_level_billing_history_response_attributes.py

@@ -26,11 +26,12 @@ class ResourceLevelBillingHistoryResponseAttributes(BaseModel):
     """
     ResourceLevelBillingHistoryResponseAttributes
     """ # noqa: E501
+    contract_id: Optional[StrictInt] = None
     id: Optional[StrictStr] = None
     infrahub_id: Optional[StrictInt] = None
     resource_name: Optional[StrictStr] = None
     status: Optional[StrictStr] = None
-    __properties: ClassVar[List[str]] = ["id", "infrahub_id", "resource_name", "status"]
+    __properties: ClassVar[List[str]] = ["contract_id", "id", "infrahub_id", "resource_name", "status"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -83,6 +84,7 @@ class ResourceLevelBillingHistoryResponseAttributes(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
+            "contract_id": obj.get("contract_id"),
             "id": obj.get("id"),
             "infrahub_id": obj.get("infrahub_id"),
             "resource_name": obj.get("resource_name"),

hyperstack/models/{get_all_contracts_response_model.py → resource_level_bucket_billing_details_response_model.py}

@@ -19,18 +19,18 @@ import json
 
 from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.get_all_contract_fields import GetAllContractFields
+from ..models.resource_level_billing_bucket_details_resources import ResourceLevelBillingBucketDetailsResources
 from typing import Optional, Set
 from typing_extensions import Self
 
-class GetAllContractsResponseModel(BaseModel):
+class ResourceLevelBucketBillingDetailsResponseModel(BaseModel):
     """
-    GetAllContractsResponseModel
+    ResourceLevelBucketBillingDetailsResponseModel
     """ # noqa: E501
-    contracts: Optional[List[GetAllContractFields]] = None
+    billing_history_bucket_details: Optional[ResourceLevelBillingBucketDetailsResources] = None
     message: Optional[StrictStr] = None
     status: Optional[StrictBool] = None
-    __properties: ClassVar[List[str]] = ["contracts", "message", "status"]
+    __properties: ClassVar[List[str]] = ["billing_history_bucket_details", "message", "status"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -50,7 +50,7 @@ class GetAllContractsResponseModel(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of GetAllContractsResponseModel from a JSON string"""
+        """Create an instance of ResourceLevelBucketBillingDetailsResponseModel from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -71,18 +71,14 @@ class GetAllContractsResponseModel(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of each item in contracts (list)
-        _items = []
-        if self.contracts:
-            for _item_contracts in self.contracts:
-                if _item_contracts:
-                    _items.append(_item_contracts.to_dict())
-            _dict['contracts'] = _items
+        # override the default output from pydantic by calling `to_dict()` of billing_history_bucket_details
+        if self.billing_history_bucket_details:
+            _dict['billing_history_bucket_details'] = self.billing_history_bucket_details.to_dict()
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of GetAllContractsResponseModel from a dict"""
+        """Create an instance of ResourceLevelBucketBillingDetailsResponseModel from a dict"""
         if obj is None:
             return None
 
@@ -90,7 +86,7 @@ class GetAllContractsResponseModel(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "contracts": [GetAllContractFields.from_dict(_item) for _item in obj["contracts"]] if obj.get("contracts") is not None else None,
+            "billing_history_bucket_details": ResourceLevelBillingBucketDetailsResources.from_dict(obj["billing_history_bucket_details"]) if obj.get("billing_history_bucket_details") is not None else None,
             "message": obj.get("message"),
             "status": obj.get("status")
         })

hyperstack/models/{contract_billing_history_response_model.py → resource_level_bucket_billing_history_response_model.py}

@@ -19,18 +19,18 @@ import json
 
 from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.contract_billing_history import ContractBillingHistory
+from ..models.resource_level_billing_history import ResourceLevelBillingHistory
 from typing import Optional, Set
 from typing_extensions import Self
 
-class ContractBillingHistoryResponseModel(BaseModel):
+class ResourceLevelBucketBillingHistoryResponseModel(BaseModel):
     """
-    ContractBillingHistoryResponseModel
+    ResourceLevelBucketBillingHistoryResponseModel
     """ # noqa: E501
-    billing_history_contract: Optional[ContractBillingHistory] = None
+    billing_history_bucket: Optional[ResourceLevelBillingHistory] = None
     message: Optional[StrictStr] = None
     status: Optional[StrictBool] = None
-    __properties: ClassVar[List[str]] = ["billing_history_contract", "message", "status"]
+    __properties: ClassVar[List[str]] = ["billing_history_bucket", "message", "status"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -50,7 +50,7 @@ class ContractBillingHistoryResponseModel(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of ContractBillingHistoryResponseModel from a JSON string"""
+        """Create an instance of ResourceLevelBucketBillingHistoryResponseModel from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -71,14 +71,14 @@ class ContractBillingHistoryResponseModel(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of billing_history_contract
-        if self.billing_history_contract:
-            _dict['billing_history_contract'] = self.billing_history_contract.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of billing_history_bucket
+        if self.billing_history_bucket:
+            _dict['billing_history_bucket'] = self.billing_history_bucket.to_dict()
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of ContractBillingHistoryResponseModel from a dict"""
+        """Create an instance of ResourceLevelBucketBillingHistoryResponseModel from a dict"""
         if obj is None:
             return None
 
@@ -86,7 +86,7 @@ class ContractBillingHistoryResponseModel(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "billing_history_contract": ContractBillingHistory.from_dict(obj["billing_history_contract"]) if obj.get("billing_history_contract") is not None else None,
+            "billing_history_bucket": ResourceLevelBillingHistory.from_dict(obj["billing_history_bucket"]) if obj.get("billing_history_bucket") is not None else None,
             "message": obj.get("message"),
             "status": obj.get("status")
         })

hyperstack/models/resource_level_cluster_billing_details_response_model.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    Infrahub-API
+
+    Leverage the Infrahub API and Hyperstack platform to easily create, manage, and scale powerful GPU virtual machines and their associated resources.   Access this SDK to automate the deployment of your workloads and streamline your infrastructure management.  To contribute, please raise an issue with a bug report, feature request, feedback, or general inquiry.
+
+    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, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from ..models.resource_level_billing_history_resources_cluster import ResourceLevelBillingHistoryResourcesCluster
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ResourceLevelClusterBillingDetailsResponseModel(BaseModel):
+    """
+    ResourceLevelClusterBillingDetailsResponseModel
+    """ # noqa: E501
+    billing_history_cluster_details: Optional[ResourceLevelBillingHistoryResourcesCluster] = None
+    message: Optional[StrictStr] = None
+    status: Optional[StrictBool] = None
+    __properties: ClassVar[List[str]] = ["billing_history_cluster_details", "message", "status"]
+
+    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 ResourceLevelClusterBillingDetailsResponseModel 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 billing_history_cluster_details
+        if self.billing_history_cluster_details:
+            _dict['billing_history_cluster_details'] = self.billing_history_cluster_details.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ResourceLevelClusterBillingDetailsResponseModel from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "billing_history_cluster_details": ResourceLevelBillingHistoryResourcesCluster.from_dict(obj["billing_history_cluster_details"]) if obj.get("billing_history_cluster_details") is not None else None,
+            "message": obj.get("message"),
+            "status": obj.get("status")
+        })
+        return _obj
+
+

hyperstack/models/resource_level_cluster_billing_history_response_model.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    Infrahub-API
+
+    Leverage the Infrahub API and Hyperstack platform to easily create, manage, and scale powerful GPU virtual machines and their associated resources.   Access this SDK to automate the deployment of your workloads and streamline your infrastructure management.  To contribute, please raise an issue with a bug report, feature request, feedback, or general inquiry.
+
+    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, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from ..models.resource_level_billing_history import ResourceLevelBillingHistory
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ResourceLevelClusterBillingHistoryResponseModel(BaseModel):
+    """
+    ResourceLevelClusterBillingHistoryResponseModel
+    """ # noqa: E501
+    billing_history_cluster: Optional[ResourceLevelBillingHistory] = None
+    message: Optional[StrictStr] = None
+    status: Optional[StrictBool] = None
+    __properties: ClassVar[List[str]] = ["billing_history_cluster", "message", "status"]
+
+    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 ResourceLevelClusterBillingHistoryResponseModel 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 billing_history_cluster
+        if self.billing_history_cluster:
+            _dict['billing_history_cluster'] = self.billing_history_cluster.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ResourceLevelClusterBillingHistoryResponseModel from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "billing_history_cluster": ResourceLevelBillingHistory.from_dict(obj["billing_history_cluster"]) if obj.get("billing_history_cluster") is not None else None,
+            "message": obj.get("message"),
+            "status": obj.get("status")
+        })
+        return _obj
+
+

hyperstack/models/{get_discount_detail_response.py → resource_level_cluster_graph_billing_details_response_model.py}

@@ -19,18 +19,18 @@ import json
 
 from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.discount_entity_model import DiscountEntityModel
+from ..models.resource_level_graph_billing_detail_volume import ResourceLevelGraphBillingDetailVolume
 from typing import Optional, Set
 from typing_extensions import Self
 
-class GetDiscountDetailResponse(BaseModel):
+class ResourceLevelClusterGraphBillingDetailsResponseModel(BaseModel):
     """
-    GetDiscountDetailResponse
+    ResourceLevelClusterGraphBillingDetailsResponseModel
     """ # noqa: E501
-    discounts_entity: Optional[DiscountEntityModel] = None
+    billing_history_cluster_details: Optional[ResourceLevelGraphBillingDetailVolume] = None
     message: Optional[StrictStr] = None
     status: Optional[StrictBool] = None
-    __properties: ClassVar[List[str]] = ["discounts_entity", "message", "status"]
+    __properties: ClassVar[List[str]] = ["billing_history_cluster_details", "message", "status"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -50,7 +50,7 @@ class GetDiscountDetailResponse(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of GetDiscountDetailResponse from a JSON string"""
+        """Create an instance of ResourceLevelClusterGraphBillingDetailsResponseModel from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -71,14 +71,14 @@ class GetDiscountDetailResponse(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of discounts_entity
-        if self.discounts_entity:
-            _dict['discounts_entity'] = self.discounts_entity.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of billing_history_cluster_details
+        if self.billing_history_cluster_details:
+            _dict['billing_history_cluster_details'] = self.billing_history_cluster_details.to_dict()
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of GetDiscountDetailResponse from a dict"""
+        """Create an instance of ResourceLevelClusterGraphBillingDetailsResponseModel from a dict"""
         if obj is None:
             return None
 
@@ -86,7 +86,7 @@ class GetDiscountDetailResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "discounts_entity": DiscountEntityModel.from_dict(obj["discounts_entity"]) if obj.get("discounts_entity") is not None else None,
+            "billing_history_cluster_details": ResourceLevelGraphBillingDetailVolume.from_dict(obj["billing_history_cluster_details"]) if obj.get("billing_history_cluster_details") is not None else None,
             "message": obj.get("message"),
             "status": obj.get("status")
         })

hyperstack/models/{organization_object_response.py → resource_level_graph_billing_details_bucket.py}

@@ -19,17 +19,19 @@ import json
 
 from pydantic import BaseModel, ConfigDict, StrictInt
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.infrahub_resource_object_response import InfrahubResourceObjectResponse
+from ..models.resource_level_billing_bucket_details_resources import ResourceLevelBillingBucketDetailsResources
 from typing import Optional, Set
 from typing_extensions import Self
 
-class OrganizationObjectResponse(BaseModel):
+class ResourceLevelGraphBillingDetailsBucket(BaseModel):
     """
-    OrganizationObjectResponse
+    ResourceLevelGraphBillingDetailsBucket
     """ # noqa: E501
+    billing_history: Optional[List[ResourceLevelBillingBucketDetailsResources]] = None
+    granularity: Optional[StrictInt] = None
     org_id: Optional[StrictInt] = None
-    resources: Optional[List[InfrahubResourceObjectResponse]] = None
-    __properties: ClassVar[List[str]] = ["org_id", "resources"]
+    total_count: Optional[StrictInt] = None
+    __properties: ClassVar[List[str]] = ["billing_history", "granularity", "org_id", "total_count"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -49,7 +51,7 @@ class OrganizationObjectResponse(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of OrganizationObjectResponse from a JSON string"""
+        """Create an instance of ResourceLevelGraphBillingDetailsBucket from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -70,18 +72,18 @@ class OrganizationObjectResponse(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of each item in resources (list)
+        # override the default output from pydantic by calling `to_dict()` of each item in billing_history (list)
         _items = []
-        if self.resources:
-            for _item_resources in self.resources:
-                if _item_resources:
-                    _items.append(_item_resources.to_dict())
-            _dict['resources'] = _items
+        if self.billing_history:
+            for _item_billing_history in self.billing_history:
+                if _item_billing_history:
+                    _items.append(_item_billing_history.to_dict())
+            _dict['billing_history'] = _items
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of OrganizationObjectResponse from a dict"""
+        """Create an instance of ResourceLevelGraphBillingDetailsBucket from a dict"""
         if obj is None:
             return None
 
@@ -89,8 +91,10 @@ class OrganizationObjectResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
+            "billing_history": [ResourceLevelBillingBucketDetailsResources.from_dict(_item) for _item in obj["billing_history"]] if obj.get("billing_history") is not None else None,
+            "granularity": obj.get("granularity"),
             "org_id": obj.get("org_id"),
-            "resources": [InfrahubResourceObjectResponse.from_dict(_item) for _item in obj["resources"]] if obj.get("resources") is not None else None
+            "total_count": obj.get("total_count")
         })
         return _obj
 

hyperstack/models/{update_discounts_status_payload.py → secondary_color.py}

@@ -18,16 +18,17 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, StrictStr
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
-class UpdateDiscountsStatusPayload(BaseModel):
+class SecondaryColor(BaseModel):
     """
-    UpdateDiscountsStatusPayload
+    SecondaryColor
     """ # noqa: E501
-    discount_status: StrictStr
-    __properties: ClassVar[List[str]] = ["discount_status"]
+    dark: Optional[StrictStr] = None
+    light: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["dark", "light"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -47,7 +48,7 @@ class UpdateDiscountsStatusPayload(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of UpdateDiscountsStatusPayload from a JSON string"""
+        """Create an instance of SecondaryColor from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -72,7 +73,7 @@ class UpdateDiscountsStatusPayload(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of UpdateDiscountsStatusPayload from a dict"""
+        """Create an instance of SecondaryColor from a dict"""
         if obj is None:
             return None
 
@@ -80,7 +81,8 @@ class UpdateDiscountsStatusPayload(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "discount_status": obj.get("discount_status")
+            "dark": obj.get("dark"),
+            "light": obj.get("light")
         })
         return _obj