robosystems-client 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

robosystems_client/models/auth_response.py

@@ -7,6 +7,7 @@ from attrs import field as _attrs_field
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
+  from ..models.auth_response_org_type_0 import AuthResponseOrgType0
   from ..models.auth_response_user import AuthResponseUser
 
 
@@ -20,6 +21,8 @@ class AuthResponse:
   Attributes:
       user (AuthResponseUser): User information
       message (str): Success message
+      org (Union['AuthResponseOrgType0', None, Unset]): Organization information (personal org created automatically
+          on registration)
       token (Union[None, Unset, str]): JWT authentication token (optional for cookie-based auth)
       expires_in (Union[None, Unset, int]): Token expiry time in seconds from now
       refresh_threshold (Union[None, Unset, int]): Recommended refresh threshold in seconds before expiry
@@ -27,16 +30,27 @@ class AuthResponse:
 
   user: "AuthResponseUser"
   message: str
+  org: Union["AuthResponseOrgType0", None, Unset] = UNSET
   token: Union[None, Unset, str] = UNSET
   expires_in: Union[None, Unset, int] = UNSET
   refresh_threshold: Union[None, Unset, int] = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
+    from ..models.auth_response_org_type_0 import AuthResponseOrgType0
+
     user = self.user.to_dict()
 
     message = self.message
 
+    org: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.org, Unset):
+      org = UNSET
+    elif isinstance(self.org, AuthResponseOrgType0):
+      org = self.org.to_dict()
+    else:
+      org = self.org
+
     token: Union[None, Unset, str]
     if isinstance(self.token, Unset):
       token = UNSET
@@ -63,6 +77,8 @@ class AuthResponse:
         "message": message,
       }
     )
+    if org is not UNSET:
+      field_dict["org"] = org
     if token is not UNSET:
       field_dict["token"] = token
     if expires_in is not UNSET:
@@ -74,6 +90,7 @@ class AuthResponse:
 
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.auth_response_org_type_0 import AuthResponseOrgType0
     from ..models.auth_response_user import AuthResponseUser
 
     d = dict(src_dict)
@@ -81,6 +98,23 @@ class AuthResponse:
 
     message = d.pop("message")
 
+    def _parse_org(data: object) -> Union["AuthResponseOrgType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        org_type_0 = AuthResponseOrgType0.from_dict(data)
+
+        return org_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["AuthResponseOrgType0", None, Unset], data)
+
+    org = _parse_org(d.pop("org", UNSET))
+
     def _parse_token(data: object) -> Union[None, Unset, str]:
       if data is None:
         return data
@@ -111,6 +145,7 @@ class AuthResponse:
     auth_response = cls(
       user=user,
       message=message,
+      org=org,
       token=token,
       expires_in=expires_in,
       refresh_threshold=refresh_threshold,

robosystems_client/models/{user_usage_response_graphs.py → auth_response_org_type_0.py}

@@ -4,12 +4,12 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="UserUsageResponseGraphs")
+T = TypeVar("T", bound="AuthResponseOrgType0")
 
 
 @_attrs_define
-class UserUsageResponseGraphs:
-  """Graph usage statistics (current/limit/remaining)"""
+class AuthResponseOrgType0:
+  """ """
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -22,10 +22,10 @@ class UserUsageResponseGraphs:
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    user_usage_response_graphs = cls()
+    auth_response_org_type_0 = cls()
 
-    user_usage_response_graphs.additional_properties = d
-    return user_usage_response_graphs
+    auth_response_org_type_0.additional_properties = d
+    return auth_response_org_type_0
 
   @property
   def additional_keys(self) -> list[str]:

robosystems_client/models/billing_customer.py

@@ -15,18 +15,18 @@ T = TypeVar("T", bound="BillingCustomer")
 
 @_attrs_define
 class BillingCustomer:
-  """Billing customer information.
+  """Billing customer information for an organization.
 
   Attributes:
-      user_id (str): User ID
-      has_payment_method (bool): Whether customer has a payment method on file
+      org_id (str): Organization ID
+      has_payment_method (bool): Whether organization has a payment method on file
       invoice_billing_enabled (bool): Whether invoice billing is enabled (enterprise customers)
       payment_methods (list['PaymentMethod']): List of payment methods on file
       created_at (str): Customer creation timestamp (ISO format)
       stripe_customer_id (Union[None, Unset, str]): Stripe customer ID if applicable
   """
 
-  user_id: str
+  org_id: str
   has_payment_method: bool
   invoice_billing_enabled: bool
   payment_methods: list["PaymentMethod"]
@@ -35,7 +35,7 @@ class BillingCustomer:
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
-    user_id = self.user_id
+    org_id = self.org_id
 
     has_payment_method = self.has_payment_method
 
@@ -58,7 +58,7 @@ class BillingCustomer:
     field_dict.update(self.additional_properties)
     field_dict.update(
       {
-        "user_id": user_id,
+        "org_id": org_id,
         "has_payment_method": has_payment_method,
         "invoice_billing_enabled": invoice_billing_enabled,
         "payment_methods": payment_methods,
@@ -75,7 +75,7 @@ class BillingCustomer:
     from ..models.payment_method import PaymentMethod
 
     d = dict(src_dict)
-    user_id = d.pop("user_id")
+    org_id = d.pop("org_id")
 
     has_payment_method = d.pop("has_payment_method")
 
@@ -100,7 +100,7 @@ class BillingCustomer:
     stripe_customer_id = _parse_stripe_customer_id(d.pop("stripe_customer_id", UNSET))
 
     billing_customer = cls(
-      user_id=user_id,
+      org_id=org_id,
       has_payment_method=has_payment_method,
       invoice_billing_enabled=invoice_billing_enabled,
       payment_methods=payment_methods,

robosystems_client/models/checkout_response.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from typing import Any, TypeVar, Union
+from typing import Any, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -14,57 +14,100 @@ class CheckoutResponse:
   """Response from checkout session creation.
 
   Attributes:
-      checkout_url (str): URL to redirect user to for payment
-      session_id (str): Checkout session ID for status polling
-      subscription_id (str): Internal subscription ID
+      checkout_url (Union[None, Unset, str]): URL to redirect user to for payment
+      session_id (Union[None, Unset, str]): Checkout session ID for status polling
+      subscription_id (Union[None, Unset, str]): Internal subscription ID
       requires_checkout (Union[Unset, bool]): Whether checkout is required Default: True.
+      billing_disabled (Union[Unset, bool]): Whether billing is disabled on this instance Default: False.
   """
 
-  checkout_url: str
-  session_id: str
-  subscription_id: str
+  checkout_url: Union[None, Unset, str] = UNSET
+  session_id: Union[None, Unset, str] = UNSET
+  subscription_id: Union[None, Unset, str] = UNSET
   requires_checkout: Union[Unset, bool] = True
+  billing_disabled: Union[Unset, bool] = False
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
-    checkout_url = self.checkout_url
-
-    session_id = self.session_id
-
-    subscription_id = self.subscription_id
+    checkout_url: Union[None, Unset, str]
+    if isinstance(self.checkout_url, Unset):
+      checkout_url = UNSET
+    else:
+      checkout_url = self.checkout_url
+
+    session_id: Union[None, Unset, str]
+    if isinstance(self.session_id, Unset):
+      session_id = UNSET
+    else:
+      session_id = self.session_id
+
+    subscription_id: Union[None, Unset, str]
+    if isinstance(self.subscription_id, Unset):
+      subscription_id = UNSET
+    else:
+      subscription_id = self.subscription_id
 
     requires_checkout = self.requires_checkout
 
+    billing_disabled = self.billing_disabled
+
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
-    field_dict.update(
-      {
-        "checkout_url": checkout_url,
-        "session_id": session_id,
-        "subscription_id": subscription_id,
-      }
-    )
+    field_dict.update({})
+    if checkout_url is not UNSET:
+      field_dict["checkout_url"] = checkout_url
+    if session_id is not UNSET:
+      field_dict["session_id"] = session_id
+    if subscription_id is not UNSET:
+      field_dict["subscription_id"] = subscription_id
     if requires_checkout is not UNSET:
       field_dict["requires_checkout"] = requires_checkout
+    if billing_disabled is not UNSET:
+      field_dict["billing_disabled"] = billing_disabled
 
     return field_dict
 
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    checkout_url = d.pop("checkout_url")
 
-    session_id = d.pop("session_id")
+    def _parse_checkout_url(data: object) -> Union[None, Unset, str]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, str], data)
+
+    checkout_url = _parse_checkout_url(d.pop("checkout_url", UNSET))
 
-    subscription_id = d.pop("subscription_id")
+    def _parse_session_id(data: object) -> Union[None, Unset, str]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, str], data)
+
+    session_id = _parse_session_id(d.pop("session_id", UNSET))
+
+    def _parse_subscription_id(data: object) -> Union[None, Unset, str]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, str], data)
+
+    subscription_id = _parse_subscription_id(d.pop("subscription_id", UNSET))
 
     requires_checkout = d.pop("requires_checkout", UNSET)
 
+    billing_disabled = d.pop("billing_disabled", UNSET)
+
     checkout_response = cls(
       checkout_url=checkout_url,
       session_id=session_id,
       subscription_id=subscription_id,
       requires_checkout=requires_checkout,
+      billing_disabled=billing_disabled,
     )
 
     checkout_response.additional_properties = d

robosystems_client/models/checkout_status_response.py

@@ -16,7 +16,8 @@ class CheckoutStatusResponse:
   Attributes:
       status (str): Checkout status: 'pending_payment', 'provisioning', 'completed', 'failed'
       subscription_id (str): Internal subscription ID
-      resource_id (Union[None, Unset, str]): Resource ID (graph_id or repository name) once provisioned
+      resource_id (Union[None, Unset, str]): Resource ID (graph_id for both graphs and repositories) once provisioned.
+          For repositories, this is the repository slug (e.g., 'sec')
       operation_id (Union[None, Unset, str]): SSE operation ID for monitoring provisioning progress
       error (Union[None, Unset, str]): Error message if checkout failed
   """

robosystems_client/models/create_checkout_request.py

@@ -20,7 +20,8 @@ class CreateCheckoutRequest:
   Attributes:
       plan_name (str): Billing plan name (e.g., 'kuzu-standard')
       resource_type (str): Resource type ('graph' or 'repository')
-      resource_config (CreateCheckoutRequestResourceConfig): Configuration for the resource to be provisioned
+      resource_config (CreateCheckoutRequestResourceConfig): Configuration for the resource to be provisioned. For
+          repositories: {'repository_name': 'graph_id'} where graph_id is the repository slug (e.g., 'sec')
   """
 
   plan_name: str

robosystems_client/models/create_checkout_request_resource_config.py

@@ -9,7 +9,10 @@ T = TypeVar("T", bound="CreateCheckoutRequestResourceConfig")
 
 @_attrs_define
 class CreateCheckoutRequestResourceConfig:
-  """Configuration for the resource to be provisioned"""
+  """Configuration for the resource to be provisioned. For repositories: {'repository_name': 'graph_id'} where graph_id
+  is the repository slug (e.g., 'sec')
+
+  """
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 

robosystems_client/models/create_org_request.py

@@ -0,0 +1,79 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.org_type import OrgType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CreateOrgRequest")
+
+
+@_attrs_define
+class CreateOrgRequest:
+  """Request to create an organization.
+
+  Attributes:
+      name (str):
+      org_type (Union[Unset, OrgType]):
+  """
+
+  name: str
+  org_type: Union[Unset, OrgType] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    name = self.name
+
+    org_type: Union[Unset, str] = UNSET
+    if not isinstance(self.org_type, Unset):
+      org_type = self.org_type.value
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "name": name,
+      }
+    )
+    if org_type is not UNSET:
+      field_dict["org_type"] = org_type
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    name = d.pop("name")
+
+    _org_type = d.pop("org_type", UNSET)
+    org_type: Union[Unset, OrgType]
+    if isinstance(_org_type, Unset):
+      org_type = UNSET
+    else:
+      org_type = OrgType(_org_type)
+
+    create_org_request = cls(
+      name=name,
+      org_type=org_type,
+    )
+
+    create_org_request.additional_properties = d
+    return create_org_request
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> Any:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: Any) -> None:
+    self.additional_properties[key] = value
+
+  def __delitem__(self, key: str) -> None:
+    del self.additional_properties[key]
+
+  def __contains__(self, key: str) -> bool:
+    return key in self.additional_properties

robosystems_client/models/graph_subscription_tier.py

@@ -11,42 +11,45 @@ T = TypeVar("T", bound="GraphSubscriptionTier")
 
 @_attrs_define
 class GraphSubscriptionTier:
-  """Information about a graph subscription tier.
-
-  Attributes:
-      name (str): Tier name
-      display_name (str): Display name for UI
-      description (str): Tier description
-      monthly_price (float): Monthly price in USD
-      monthly_credits (int): Monthly AI credits
-      storage_included_gb (int): Storage included in GB
-      storage_overage_per_gb (float): Overage cost per GB per month
-      allowed_graph_tiers (list[str]): Allowed graph tier identifiers
-      features (list[str]): List of features
-      backup_retention_days (int): Backup retention in days
-      priority_support (bool): Whether priority support is included
-      api_rate_multiplier (float): API rate multiplier
-      backend (str): Database backend (kuzu or neo4j)
-      max_queries_per_hour (Union[None, Unset, int]): Maximum queries per hour
-      max_subgraphs (Union[None, Unset, int]): Maximum subgraphs
-      instance_type (Union[None, Unset, str]): Instance type
+  """Information about a graph infrastructure tier.
+
+  Each tier represents a per-graph subscription option with specific
+  infrastructure, performance, and pricing characteristics.
+
+      Attributes:
+          name (str): Infrastructure tier identifier (e.g., kuzu-standard)
+          display_name (str): Display name for UI
+          description (str): Tier description
+          monthly_price_per_graph (float): Monthly price in USD per graph
+          monthly_credits_per_graph (int): Monthly AI credits per graph
+          storage_included_gb (int): Storage included in GB
+          storage_overage_per_gb (float): Overage cost per GB per month
+          infrastructure (str): Infrastructure description
+          features (list[str]): List of features
+          backup_retention_days (int): Backup retention in days
+          priority_support (bool): Whether priority support is included
+          api_rate_multiplier (float): API rate multiplier
+          backend (str): Database backend (kuzu or neo4j)
+          max_queries_per_hour (Union[None, Unset, int]): Maximum queries per hour
+          max_subgraphs (Union[Unset, int]): Maximum subgraphs supported Default: 0.
+          instance_type (Union[None, Unset, str]): Instance type
   """
 
   name: str
   display_name: str
   description: str
-  monthly_price: float
-  monthly_credits: int
+  monthly_price_per_graph: float
+  monthly_credits_per_graph: int
   storage_included_gb: int
   storage_overage_per_gb: float
-  allowed_graph_tiers: list[str]
+  infrastructure: str
   features: list[str]
   backup_retention_days: int
   priority_support: bool
   api_rate_multiplier: float
   backend: str
   max_queries_per_hour: Union[None, Unset, int] = UNSET
-  max_subgraphs: Union[None, Unset, int] = UNSET
+  max_subgraphs: Union[Unset, int] = 0
   instance_type: Union[None, Unset, str] = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -57,15 +60,15 @@ class GraphSubscriptionTier:
 
     description = self.description
 
-    monthly_price = self.monthly_price
+    monthly_price_per_graph = self.monthly_price_per_graph
 
-    monthly_credits = self.monthly_credits
+    monthly_credits_per_graph = self.monthly_credits_per_graph
 
     storage_included_gb = self.storage_included_gb
 
     storage_overage_per_gb = self.storage_overage_per_gb
 
-    allowed_graph_tiers = self.allowed_graph_tiers
+    infrastructure = self.infrastructure
 
     features = self.features
 
@@ -83,11 +86,7 @@ class GraphSubscriptionTier:
     else:
       max_queries_per_hour = self.max_queries_per_hour
 
-    max_subgraphs: Union[None, Unset, int]
-    if isinstance(self.max_subgraphs, Unset):
-      max_subgraphs = UNSET
-    else:
-      max_subgraphs = self.max_subgraphs
+    max_subgraphs = self.max_subgraphs
 
     instance_type: Union[None, Unset, str]
     if isinstance(self.instance_type, Unset):
@@ -102,11 +101,11 @@ class GraphSubscriptionTier:
         "name": name,
         "display_name": display_name,
         "description": description,
-        "monthly_price": monthly_price,
-        "monthly_credits": monthly_credits,
+        "monthly_price_per_graph": monthly_price_per_graph,
+        "monthly_credits_per_graph": monthly_credits_per_graph,
         "storage_included_gb": storage_included_gb,
         "storage_overage_per_gb": storage_overage_per_gb,
-        "allowed_graph_tiers": allowed_graph_tiers,
+        "infrastructure": infrastructure,
         "features": features,
         "backup_retention_days": backup_retention_days,
         "priority_support": priority_support,
@@ -132,15 +131,15 @@ class GraphSubscriptionTier:
 
     description = d.pop("description")
 
-    monthly_price = d.pop("monthly_price")
+    monthly_price_per_graph = d.pop("monthly_price_per_graph")
 
-    monthly_credits = d.pop("monthly_credits")
+    monthly_credits_per_graph = d.pop("monthly_credits_per_graph")
 
     storage_included_gb = d.pop("storage_included_gb")
 
     storage_overage_per_gb = d.pop("storage_overage_per_gb")
 
-    allowed_graph_tiers = cast(list[str], d.pop("allowed_graph_tiers"))
+    infrastructure = d.pop("infrastructure")
 
     features = cast(list[str], d.pop("features"))
 
@@ -163,14 +162,7 @@ class GraphSubscriptionTier:
       d.pop("max_queries_per_hour", UNSET)
     )
 
-    def _parse_max_subgraphs(data: object) -> Union[None, Unset, int]:
-      if data is None:
-        return data
-      if isinstance(data, Unset):
-        return data
-      return cast(Union[None, Unset, int], data)
-
-    max_subgraphs = _parse_max_subgraphs(d.pop("max_subgraphs", UNSET))
+    max_subgraphs = d.pop("max_subgraphs", UNSET)
 
     def _parse_instance_type(data: object) -> Union[None, Unset, str]:
       if data is None:
@@ -185,11 +177,11 @@ class GraphSubscriptionTier:
       name=name,
       display_name=display_name,
       description=description,
-      monthly_price=monthly_price,
-      monthly_credits=monthly_credits,
+      monthly_price_per_graph=monthly_price_per_graph,
+      monthly_credits_per_graph=monthly_credits_per_graph,
       storage_included_gb=storage_included_gb,
       storage_overage_per_gb=storage_overage_per_gb,
-      allowed_graph_tiers=allowed_graph_tiers,
+      infrastructure=infrastructure,
       features=features,
       backup_retention_days=backup_retention_days,
       priority_support=priority_support,

robosystems_client/models/graph_subscriptions.py

@@ -16,14 +16,20 @@ T = TypeVar("T", bound="GraphSubscriptions")
 class GraphSubscriptions:
   """Graph subscription offerings.
 
-  Attributes:
-      description (str): Description of graph subscriptions
-      tiers (list['GraphSubscriptionTier']): Available tiers
-      storage (StorageInfo): Storage pricing information.
-      notes (list[str]): Important notes
+  Graph subscriptions are per-graph, not per-organization. Each graph
+  created by an organization has its own subscription with its own
+  infrastructure tier, pricing, and credit allocation.
+
+      Attributes:
+          description (str): Description of graph subscriptions
+          pricing_model (str): Pricing model type (per_graph or per_organization)
+          tiers (list['GraphSubscriptionTier']): Available infrastructure tiers
+          storage (StorageInfo): Storage pricing information.
+          notes (list[str]): Important notes
   """
 
   description: str
+  pricing_model: str
   tiers: list["GraphSubscriptionTier"]
   storage: "StorageInfo"
   notes: list[str]
@@ -32,6 +38,8 @@ class GraphSubscriptions:
   def to_dict(self) -> dict[str, Any]:
     description = self.description
 
+    pricing_model = self.pricing_model
+
     tiers = []
     for tiers_item_data in self.tiers:
       tiers_item = tiers_item_data.to_dict()
@@ -46,6 +54,7 @@ class GraphSubscriptions:
     field_dict.update(
       {
         "description": description,
+        "pricing_model": pricing_model,
         "tiers": tiers,
         "storage": storage,
         "notes": notes,
@@ -62,6 +71,8 @@ class GraphSubscriptions:
     d = dict(src_dict)
     description = d.pop("description")
 
+    pricing_model = d.pop("pricing_model")
+
     tiers = []
     _tiers = d.pop("tiers")
     for tiers_item_data in _tiers:
@@ -75,6 +86,7 @@ class GraphSubscriptions:
 
     graph_subscriptions = cls(
       description=description,
+      pricing_model=pricing_model,
       tiers=tiers,
       storage=storage,
       notes=notes,