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

hyperstack/models/auth_get_token_response_model.py

@@ -19,7 +19,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.token_fields import TokenFields
+from ..models.access_token_field import AccessTokenField
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -27,11 +27,10 @@ class AuthGetTokenResponseModel(BaseModel):
     """
     AuthGetTokenResponseModel
     """ # noqa: E501
-    first_login: Optional[StrictBool] = None
     message: Optional[StrictStr] = None
     status: Optional[StrictBool] = None
-    token: Optional[TokenFields] = None
-    __properties: ClassVar[List[str]] = ["first_login", "message", "status", "token"]
+    token: Optional[AccessTokenField] = None
+    __properties: ClassVar[List[str]] = ["message", "status", "token"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -87,10 +86,9 @@ class AuthGetTokenResponseModel(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "first_login": obj.get("first_login"),
             "message": obj.get("message"),
             "status": obj.get("status"),
-            "token": TokenFields.from_dict(obj["token"]) if obj.get("token") is not None else None
+            "token": AccessTokenField.from_dict(obj["token"]) if obj.get("token") is not None else None
         })
         return _obj
 

hyperstack/models/{future_node_model.py → beta_access_request_fields.py}

@@ -18,22 +18,32 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
-from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.future_node_stock_model import FutureNodeStockModel
 from typing import Optional, Set
 from typing_extensions import Self
 
-class FutureNodeModel(BaseModel):
+class BetaAccessRequestFields(BaseModel):
     """
-    FutureNodeModel
+    BetaAccessRequestFields
     """ # noqa: E501
-    expected_provision_date: datetime = Field(description="Date and time in the format YYYY-MM-DD HH:mm:ss")
-    id: Optional[StrictInt] = None
-    nexgen_name: Optional[StrictStr] = None
-    openstack_name: Optional[StrictStr] = None
-    stocks: Optional[List[FutureNodeStockModel]] = None
-    __properties: ClassVar[List[str]] = ["expected_provision_date", "id", "nexgen_name", "openstack_name", "stocks"]
+    created_at: Optional[datetime] = Field(default=None, description="When the request was made")
+    id: Optional[StrictInt] = Field(default=None, description="Unique identifier for the request")
+    program_id: Optional[StrictInt] = Field(default=None, description="ID of the beta program")
+    program_name: Optional[StrictStr] = Field(default=None, description="Name of the beta program")
+    status: Optional[StrictStr] = Field(default=None, description="Status of the request")
+    user_id: Optional[StrictInt] = Field(default=None, description="ID of the user who made the request")
+    __properties: ClassVar[List[str]] = ["created_at", "id", "program_id", "program_name", "status", "user_id"]
+
+    @field_validator('status')
+    def status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['requested', 'approved', 'denied', 'revoked']):
+            raise ValueError("must be one of enum values ('requested', 'approved', 'denied', 'revoked')")
+        return value
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -53,7 +63,7 @@ class FutureNodeModel(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of FutureNodeModel from a JSON string"""
+        """Create an instance of BetaAccessRequestFields from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -65,10 +75,8 @@ class FutureNodeModel(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.
-        * OpenAPI `readOnly` fields are excluded.
         """
         excluded_fields: Set[str] = set([
-            "id",
         ])
 
         _dict = self.model_dump(
@@ -76,18 +84,11 @@ class FutureNodeModel(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of each item in stocks (list)
-        _items = []
-        if self.stocks:
-            for _item_stocks in self.stocks:
-                if _item_stocks:
-                    _items.append(_item_stocks.to_dict())
-            _dict['stocks'] = _items
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of FutureNodeModel from a dict"""
+        """Create an instance of BetaAccessRequestFields from a dict"""
         if obj is None:
             return None
 
@@ -95,11 +96,12 @@ class FutureNodeModel(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "expected_provision_date": obj.get("expected_provision_date"),
+            "created_at": obj.get("created_at"),
             "id": obj.get("id"),
-            "nexgen_name": obj.get("nexgen_name"),
-            "openstack_name": obj.get("openstack_name"),
-            "stocks": [FutureNodeStockModel.from_dict(_item) for _item in obj["stocks"]] if obj.get("stocks") is not None else None
+            "program_id": obj.get("program_id"),
+            "program_name": obj.get("program_name"),
+            "status": obj.get("status"),
+            "user_id": obj.get("user_id")
         })
         return _obj
 

hyperstack/models/{create_gpu.py → beta_access_request_payload.py}

@@ -22,14 +22,13 @@ from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
-class CreateGPU(BaseModel):
+class BetaAccessRequestPayload(BaseModel):
     """
-    CreateGPU
+    BetaAccessRequestPayload
     """ # noqa: E501
-    example_metadata: Optional[StrictStr] = Field(default=None, description="A valid JSON string.")
-    name: StrictStr
-    regions: Optional[List[StrictStr]] = None
-    __properties: ClassVar[List[str]] = ["example_metadata", "name", "regions"]
+    metadata: Optional[Dict[str, Any]] = Field(default=None, description="Optional metadata for the request")
+    program: StrictStr = Field(description="Name of the beta program")
+    __properties: ClassVar[List[str]] = ["metadata", "program"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -49,7 +48,7 @@ class CreateGPU(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of CreateGPU from a JSON string"""
+        """Create an instance of BetaAccessRequestPayload from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -74,7 +73,7 @@ class CreateGPU(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of CreateGPU from a dict"""
+        """Create an instance of BetaAccessRequestPayload from a dict"""
         if obj is None:
             return None
 
@@ -82,9 +81,8 @@ class CreateGPU(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "example_metadata": obj.get("example_metadata"),
-            "name": obj.get("name"),
-            "regions": obj.get("regions")
+            "metadata": obj.get("metadata"),
+            "program": obj.get("program")
         })
         return _obj
 

hyperstack/models/{create_discount_response.py → beta_access_request_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.insert_discount_plan_fields import InsertDiscountPlanFields
+from ..models.beta_access_request_fields import BetaAccessRequestFields
 from typing import Optional, Set
 from typing_extensions import Self
 
-class CreateDiscountResponse(BaseModel):
+class BetaAccessRequestResponseModel(BaseModel):
     """
-    CreateDiscountResponse
+    BetaAccessRequestResponseModel
     """ # noqa: E501
-    discount_plan: Optional[InsertDiscountPlanFields] = None
+    beta_access_request: Optional[BetaAccessRequestFields] = None
     message: Optional[StrictStr] = None
     status: Optional[StrictBool] = None
-    __properties: ClassVar[List[str]] = ["discount_plan", "message", "status"]
+    __properties: ClassVar[List[str]] = ["beta_access_request", "message", "status"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -50,7 +50,7 @@ class CreateDiscountResponse(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of CreateDiscountResponse from a JSON string"""
+        """Create an instance of BetaAccessRequestResponseModel from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -71,14 +71,14 @@ class CreateDiscountResponse(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of discount_plan
-        if self.discount_plan:
-            _dict['discount_plan'] = self.discount_plan.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of beta_access_request
+        if self.beta_access_request:
+            _dict['beta_access_request'] = self.beta_access_request.to_dict()
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of CreateDiscountResponse from a dict"""
+        """Create an instance of BetaAccessRequestResponseModel from a dict"""
         if obj is None:
             return None
 
@@ -86,7 +86,7 @@ class CreateDiscountResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "discount_plan": InsertDiscountPlanFields.from_dict(obj["discount_plan"]) if obj.get("discount_plan") is not None else None,
+            "beta_access_request": BetaAccessRequestFields.from_dict(obj["beta_access_request"]) if obj.get("beta_access_request") is not None else None,
             "message": obj.get("message"),
             "status": obj.get("status")
         })

hyperstack/models/{export_billing_data_request.py → beta_access_status_item.py}

@@ -18,28 +18,28 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
-from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
-class ExportBillingDataRequest(BaseModel):
+class BetaAccessStatusItem(BaseModel):
     """
-    ExportBillingDataRequest
+    BetaAccessStatusItem
     """ # noqa: E501
-    end_date: datetime
-    org_id: Optional[StrictInt] = None
-    required_attributes: List[StrictStr]
-    required_metrics: List[StrictStr]
-    resource_type: StrictStr
-    start_date: datetime
-    __properties: ClassVar[List[str]] = ["end_date", "org_id", "required_attributes", "required_metrics", "resource_type", "start_date"]
-
-    @field_validator('resource_type')
-    def resource_type_validate_enum(cls, value):
+    program_name: Optional[StrictStr] = Field(default=None, description="Name of the beta program")
+    request_date: Optional[datetime] = Field(default=None, description="When the request was made")
+    status: Optional[StrictStr] = Field(default=None, description="Status of the request (requested, approved, denied, revoked)")
+    __properties: ClassVar[List[str]] = ["program_name", "request_date", "status"]
+
+    @field_validator('status')
+    def status_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in set(['virtual_machine', 'volume']):
-            raise ValueError("must be one of enum values ('virtual_machine', 'volume')")
+        if value is None:
+            return value
+
+        if value not in set(['requested', 'approved', 'denied', 'revoked']):
+            raise ValueError("must be one of enum values ('requested', 'approved', 'denied', 'revoked')")
         return value
 
     model_config = ConfigDict(
@@ -60,7 +60,7 @@ class ExportBillingDataRequest(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of ExportBillingDataRequest from a JSON string"""
+        """Create an instance of BetaAccessStatusItem from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -85,7 +85,7 @@ class ExportBillingDataRequest(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of ExportBillingDataRequest from a dict"""
+        """Create an instance of BetaAccessStatusItem from a dict"""
         if obj is None:
             return None
 
@@ -93,12 +93,9 @@ class ExportBillingDataRequest(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "end_date": obj.get("end_date"),
-            "org_id": obj.get("org_id"),
-            "required_attributes": obj.get("required_attributes"),
-            "required_metrics": obj.get("required_metrics"),
-            "resource_type": obj.get("resource_type"),
-            "start_date": obj.get("start_date")
+            "program_name": obj.get("program_name"),
+            "request_date": obj.get("request_date"),
+            "status": obj.get("status")
         })
         return _obj
 

hyperstack/models/{get_all_discount_for_all_organization_response.py → beta_access_status_response_model.py}

@@ -17,20 +17,20 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.get_all_discounts_fields import GetAllDiscountsFields
+from ..models.beta_access_status_item import BetaAccessStatusItem
 from typing import Optional, Set
 from typing_extensions import Self
 
-class GetAllDiscountForAllOrganizationResponse(BaseModel):
+class BetaAccessStatusResponseModel(BaseModel):
     """
-    GetAllDiscountForAllOrganizationResponse
+    BetaAccessStatusResponseModel
     """ # noqa: E501
-    discount_plans: Optional[List[GetAllDiscountsFields]] = None
+    beta_access_requests: Optional[List[BetaAccessStatusItem]] = Field(default=None, description="List of beta access requests")
     message: Optional[StrictStr] = None
     status: Optional[StrictBool] = None
-    __properties: ClassVar[List[str]] = ["discount_plans", "message", "status"]
+    __properties: ClassVar[List[str]] = ["beta_access_requests", "message", "status"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -50,7 +50,7 @@ class GetAllDiscountForAllOrganizationResponse(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of GetAllDiscountForAllOrganizationResponse from a JSON string"""
+        """Create an instance of BetaAccessStatusResponseModel from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -71,18 +71,18 @@ class GetAllDiscountForAllOrganizationResponse(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of each item in discount_plans (list)
+        # override the default output from pydantic by calling `to_dict()` of each item in beta_access_requests (list)
         _items = []
-        if self.discount_plans:
-            for _item_discount_plans in self.discount_plans:
-                if _item_discount_plans:
-                    _items.append(_item_discount_plans.to_dict())
-            _dict['discount_plans'] = _items
+        if self.beta_access_requests:
+            for _item_beta_access_requests in self.beta_access_requests:
+                if _item_beta_access_requests:
+                    _items.append(_item_beta_access_requests.to_dict())
+            _dict['beta_access_requests'] = _items
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of GetAllDiscountForAllOrganizationResponse from a dict"""
+        """Create an instance of BetaAccessStatusResponseModel from a dict"""
         if obj is None:
             return None
 
@@ -90,7 +90,7 @@ class GetAllDiscountForAllOrganizationResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "discount_plans": [GetAllDiscountsFields.from_dict(_item) for _item in obj["discount_plans"]] if obj.get("discount_plans") is not None else None,
+            "beta_access_requests": [BetaAccessStatusItem.from_dict(_item) for _item in obj["beta_access_requests"]] if obj.get("beta_access_requests") is not None else None,
             "message": obj.get("message"),
             "status": obj.get("status")
         })

hyperstack/models/{exclude_billing_post_response.py → billing_history.py}

@@ -19,16 +19,17 @@ import json
 
 from pydantic import BaseModel, ConfigDict
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.data import Data
+from ..models.attributes import Attributes
 from typing import Optional, Set
 from typing_extensions import Self
 
-class ExcludeBillingPostResponse(BaseModel):
+class BillingHistory(BaseModel):
     """
-    ExcludeBillingPostResponse
+    BillingHistory
     """ # noqa: E501
-    data: Optional[Data] = None
-    __properties: ClassVar[List[str]] = ["data"]
+    attributes: Optional[Attributes] = None
+    metrics: Optional[Dict[str, Any]] = None
+    __properties: ClassVar[List[str]] = ["attributes", "metrics"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -48,7 +49,7 @@ class ExcludeBillingPostResponse(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of ExcludeBillingPostResponse from a JSON string"""
+        """Create an instance of BillingHistory from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -69,14 +70,14 @@ class ExcludeBillingPostResponse(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of data
-        if self.data:
-            _dict['data'] = self.data.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of attributes
+        if self.attributes:
+            _dict['attributes'] = self.attributes.to_dict()
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of ExcludeBillingPostResponse from a dict"""
+        """Create an instance of BillingHistory from a dict"""
         if obj is None:
             return None
 
@@ -84,7 +85,8 @@ class ExcludeBillingPostResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "data": Data.from_dict(obj["data"]) if obj.get("data") is not None else None
+            "attributes": Attributes.from_dict(obj["attributes"]) if obj.get("attributes") is not None else None,
+            "metrics": obj.get("metrics")
         })
         return _obj
 

hyperstack/models/billing_history_data_synthesis_details.py

@@ -0,0 +1,105 @@
+# 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, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from ..models.billing_history import BillingHistory
+from ..models.pagination import Pagination
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BillingHistoryDataSynthesisDetails(BaseModel):
+    """
+    BillingHistoryDataSynthesisDetails
+    """ # noqa: E501
+    billing_history: Optional[List[BillingHistory]] = None
+    org_id: Optional[StrictInt] = None
+    pagination: Optional[Pagination] = None
+    total_count: Optional[StrictInt] = None
+    __properties: ClassVar[List[str]] = ["billing_history", "org_id", "pagination", "total_count"]
+
+    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 BillingHistoryDataSynthesisDetails 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 billing_history (list)
+        _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
+        # override the default output from pydantic by calling `to_dict()` of pagination
+        if self.pagination:
+            _dict['pagination'] = self.pagination.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BillingHistoryDataSynthesisDetails 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": [BillingHistory.from_dict(_item) for _item in obj["billing_history"]] if obj.get("billing_history") is not None else None,
+            "org_id": obj.get("org_id"),
+            "pagination": Pagination.from_dict(obj["pagination"]) if obj.get("pagination") is not None else None,
+            "total_count": obj.get("total_count")
+        })
+        return _obj
+
+

hyperstack/models/{vm_usage_response.py → billing_history_fine_tuning.py}

@@ -17,21 +17,22 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictBool, StrictInt, StrictStr
+from pydantic import BaseModel, ConfigDict, StrictInt
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.virtual_machine_usage import VirtualMachineUsage
+from ..models.billing_history import BillingHistory
+from ..models.pagination import Pagination
 from typing import Optional, Set
 from typing_extensions import Self
 
-class VMUsageResponse(BaseModel):
+class BillingHistoryFineTuning(BaseModel):
     """
-    VMUsageResponse
+    BillingHistoryFineTuning
     """ # noqa: E501
-    message: Optional[StrictStr] = None
+    billing_history: Optional[List[BillingHistory]] = None
     org_id: Optional[StrictInt] = None
-    status: Optional[StrictBool] = None
-    virtual_machines: Optional[List[VirtualMachineUsage]] = None
-    __properties: ClassVar[List[str]] = ["message", "org_id", "status", "virtual_machines"]
+    pagination: Optional[Pagination] = None
+    total_count: Optional[StrictInt] = None
+    __properties: ClassVar[List[str]] = ["billing_history", "org_id", "pagination", "total_count"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -51,7 +52,7 @@ class VMUsageResponse(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of VMUsageResponse from a JSON string"""
+        """Create an instance of BillingHistoryFineTuning from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -72,18 +73,21 @@ class VMUsageResponse(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of each item in virtual_machines (list)
+        # override the default output from pydantic by calling `to_dict()` of each item in billing_history (list)
         _items = []
-        if self.virtual_machines:
-            for _item_virtual_machines in self.virtual_machines:
-                if _item_virtual_machines:
-                    _items.append(_item_virtual_machines.to_dict())
-            _dict['virtual_machines'] = _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
+        # override the default output from pydantic by calling `to_dict()` of pagination
+        if self.pagination:
+            _dict['pagination'] = self.pagination.to_dict()
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of VMUsageResponse from a dict"""
+        """Create an instance of BillingHistoryFineTuning from a dict"""
         if obj is None:
             return None
 
@@ -91,10 +95,10 @@ class VMUsageResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "message": obj.get("message"),
+            "billing_history": [BillingHistory.from_dict(_item) for _item in obj["billing_history"]] if obj.get("billing_history") is not None else None,
             "org_id": obj.get("org_id"),
-            "status": obj.get("status"),
-            "virtual_machines": [VirtualMachineUsage.from_dict(_item) for _item in obj["virtual_machines"]] if obj.get("virtual_machines") is not None else None
+            "pagination": Pagination.from_dict(obj["pagination"]) if obj.get("pagination") is not None else None,
+            "total_count": obj.get("total_count")
         })
         return _obj