ory-client 1.9.0__py3-none-any.whl → 1.11.6__py3-none-any.whl

ory_client/models/o_auth2_client_token_lifespans.py

@@ -0,0 +1,270 @@
+# coding: utf-8
+
+"""
+    Ory APIs
+
+    Documentation for all public and administrative Ory APIs. Administrative APIs can only be accessed with a valid Personal Access Token. Public APIs are mostly used in browsers. 
+
+    The version of the OpenAPI document: v1.11.6
+    Contact: support@ory.sh
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OAuth2ClientTokenLifespans(BaseModel):
+    """
+    Lifespans of different token types issued for this OAuth 2.0 Client.
+    """ # noqa: E501
+    authorization_code_grant_access_token_lifespan: Optional[Annotated[str, Field(strict=True)]] = None
+    authorization_code_grant_id_token_lifespan: Optional[Annotated[str, Field(strict=True)]] = None
+    authorization_code_grant_refresh_token_lifespan: Optional[Annotated[str, Field(strict=True)]] = None
+    client_credentials_grant_access_token_lifespan: Optional[Annotated[str, Field(strict=True)]] = None
+    implicit_grant_access_token_lifespan: Optional[Annotated[str, Field(strict=True)]] = None
+    implicit_grant_id_token_lifespan: Optional[Annotated[str, Field(strict=True)]] = None
+    jwt_bearer_grant_access_token_lifespan: Optional[Annotated[str, Field(strict=True)]] = None
+    refresh_token_grant_access_token_lifespan: Optional[Annotated[str, Field(strict=True)]] = None
+    refresh_token_grant_id_token_lifespan: Optional[Annotated[str, Field(strict=True)]] = None
+    refresh_token_grant_refresh_token_lifespan: Optional[Annotated[str, Field(strict=True)]] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["authorization_code_grant_access_token_lifespan", "authorization_code_grant_id_token_lifespan", "authorization_code_grant_refresh_token_lifespan", "client_credentials_grant_access_token_lifespan", "implicit_grant_access_token_lifespan", "implicit_grant_id_token_lifespan", "jwt_bearer_grant_access_token_lifespan", "refresh_token_grant_access_token_lifespan", "refresh_token_grant_id_token_lifespan", "refresh_token_grant_refresh_token_lifespan"]
+
+    @field_validator('authorization_code_grant_access_token_lifespan')
+    def authorization_code_grant_access_token_lifespan_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9]+(ns|us|ms|s|m|h)$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+(ns|us|ms|s|m|h)$/")
+        return value
+
+    @field_validator('authorization_code_grant_id_token_lifespan')
+    def authorization_code_grant_id_token_lifespan_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9]+(ns|us|ms|s|m|h)$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+(ns|us|ms|s|m|h)$/")
+        return value
+
+    @field_validator('authorization_code_grant_refresh_token_lifespan')
+    def authorization_code_grant_refresh_token_lifespan_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9]+(ns|us|ms|s|m|h)$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+(ns|us|ms|s|m|h)$/")
+        return value
+
+    @field_validator('client_credentials_grant_access_token_lifespan')
+    def client_credentials_grant_access_token_lifespan_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9]+(ns|us|ms|s|m|h)$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+(ns|us|ms|s|m|h)$/")
+        return value
+
+    @field_validator('implicit_grant_access_token_lifespan')
+    def implicit_grant_access_token_lifespan_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9]+(ns|us|ms|s|m|h)$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+(ns|us|ms|s|m|h)$/")
+        return value
+
+    @field_validator('implicit_grant_id_token_lifespan')
+    def implicit_grant_id_token_lifespan_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9]+(ns|us|ms|s|m|h)$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+(ns|us|ms|s|m|h)$/")
+        return value
+
+    @field_validator('jwt_bearer_grant_access_token_lifespan')
+    def jwt_bearer_grant_access_token_lifespan_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9]+(ns|us|ms|s|m|h)$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+(ns|us|ms|s|m|h)$/")
+        return value
+
+    @field_validator('refresh_token_grant_access_token_lifespan')
+    def refresh_token_grant_access_token_lifespan_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9]+(ns|us|ms|s|m|h)$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+(ns|us|ms|s|m|h)$/")
+        return value
+
+    @field_validator('refresh_token_grant_id_token_lifespan')
+    def refresh_token_grant_id_token_lifespan_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9]+(ns|us|ms|s|m|h)$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+(ns|us|ms|s|m|h)$/")
+        return value
+
+    @field_validator('refresh_token_grant_refresh_token_lifespan')
+    def refresh_token_grant_refresh_token_lifespan_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9]+(ns|us|ms|s|m|h)$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+(ns|us|ms|s|m|h)$/")
+        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"""
+        # 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 OAuth2ClientTokenLifespans 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.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        # set to None if authorization_code_grant_access_token_lifespan (nullable) is None
+        # and model_fields_set contains the field
+        if self.authorization_code_grant_access_token_lifespan is None and "authorization_code_grant_access_token_lifespan" in self.model_fields_set:
+            _dict['authorization_code_grant_access_token_lifespan'] = None
+
+        # set to None if authorization_code_grant_id_token_lifespan (nullable) is None
+        # and model_fields_set contains the field
+        if self.authorization_code_grant_id_token_lifespan is None and "authorization_code_grant_id_token_lifespan" in self.model_fields_set:
+            _dict['authorization_code_grant_id_token_lifespan'] = None
+
+        # set to None if authorization_code_grant_refresh_token_lifespan (nullable) is None
+        # and model_fields_set contains the field
+        if self.authorization_code_grant_refresh_token_lifespan is None and "authorization_code_grant_refresh_token_lifespan" in self.model_fields_set:
+            _dict['authorization_code_grant_refresh_token_lifespan'] = None
+
+        # set to None if client_credentials_grant_access_token_lifespan (nullable) is None
+        # and model_fields_set contains the field
+        if self.client_credentials_grant_access_token_lifespan is None and "client_credentials_grant_access_token_lifespan" in self.model_fields_set:
+            _dict['client_credentials_grant_access_token_lifespan'] = None
+
+        # set to None if implicit_grant_access_token_lifespan (nullable) is None
+        # and model_fields_set contains the field
+        if self.implicit_grant_access_token_lifespan is None and "implicit_grant_access_token_lifespan" in self.model_fields_set:
+            _dict['implicit_grant_access_token_lifespan'] = None
+
+        # set to None if implicit_grant_id_token_lifespan (nullable) is None
+        # and model_fields_set contains the field
+        if self.implicit_grant_id_token_lifespan is None and "implicit_grant_id_token_lifespan" in self.model_fields_set:
+            _dict['implicit_grant_id_token_lifespan'] = None
+
+        # set to None if jwt_bearer_grant_access_token_lifespan (nullable) is None
+        # and model_fields_set contains the field
+        if self.jwt_bearer_grant_access_token_lifespan is None and "jwt_bearer_grant_access_token_lifespan" in self.model_fields_set:
+            _dict['jwt_bearer_grant_access_token_lifespan'] = None
+
+        # set to None if refresh_token_grant_access_token_lifespan (nullable) is None
+        # and model_fields_set contains the field
+        if self.refresh_token_grant_access_token_lifespan is None and "refresh_token_grant_access_token_lifespan" in self.model_fields_set:
+            _dict['refresh_token_grant_access_token_lifespan'] = None
+
+        # set to None if refresh_token_grant_id_token_lifespan (nullable) is None
+        # and model_fields_set contains the field
+        if self.refresh_token_grant_id_token_lifespan is None and "refresh_token_grant_id_token_lifespan" in self.model_fields_set:
+            _dict['refresh_token_grant_id_token_lifespan'] = None
+
+        # set to None if refresh_token_grant_refresh_token_lifespan (nullable) is None
+        # and model_fields_set contains the field
+        if self.refresh_token_grant_refresh_token_lifespan is None and "refresh_token_grant_refresh_token_lifespan" in self.model_fields_set:
+            _dict['refresh_token_grant_refresh_token_lifespan'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OAuth2ClientTokenLifespans from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "authorization_code_grant_access_token_lifespan": obj.get("authorization_code_grant_access_token_lifespan"),
+            "authorization_code_grant_id_token_lifespan": obj.get("authorization_code_grant_id_token_lifespan"),
+            "authorization_code_grant_refresh_token_lifespan": obj.get("authorization_code_grant_refresh_token_lifespan"),
+            "client_credentials_grant_access_token_lifespan": obj.get("client_credentials_grant_access_token_lifespan"),
+            "implicit_grant_access_token_lifespan": obj.get("implicit_grant_access_token_lifespan"),
+            "implicit_grant_id_token_lifespan": obj.get("implicit_grant_id_token_lifespan"),
+            "jwt_bearer_grant_access_token_lifespan": obj.get("jwt_bearer_grant_access_token_lifespan"),
+            "refresh_token_grant_access_token_lifespan": obj.get("refresh_token_grant_access_token_lifespan"),
+            "refresh_token_grant_id_token_lifespan": obj.get("refresh_token_grant_id_token_lifespan"),
+            "refresh_token_grant_refresh_token_lifespan": obj.get("refresh_token_grant_refresh_token_lifespan")
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

ory_client/models/o_auth2_consent_request.py

@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+    Ory APIs
+
+    Documentation for all public and administrative Ory APIs. Administrative APIs can only be accessed with a valid Personal Access Token. Public APIs are mostly used in browsers. 
+
+    The version of the OpenAPI document: v1.11.6
+    Contact: support@ory.sh
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from ory_client.models.o_auth2_client import OAuth2Client
+from ory_client.models.o_auth2_consent_request_open_id_connect_context import OAuth2ConsentRequestOpenIDConnectContext
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OAuth2ConsentRequest(BaseModel):
+    """
+    OAuth2ConsentRequest
+    """ # noqa: E501
+    acr: Optional[StrictStr] = Field(default=None, description="ACR represents the Authentication AuthorizationContext Class Reference value for this authentication session. You can use it to express that, for example, a user authenticated using two factor authentication.")
+    amr: Optional[List[StrictStr]] = None
+    challenge: StrictStr = Field(description="ID is the identifier (\"authorization challenge\") of the consent authorization request. It is used to identify the session.")
+    client: Optional[OAuth2Client] = None
+    context: Optional[Dict[str, Any]] = None
+    login_challenge: Optional[StrictStr] = Field(default=None, description="LoginChallenge is the login challenge this consent challenge belongs to. It can be used to associate a login and consent request in the login & consent app.")
+    login_session_id: Optional[StrictStr] = Field(default=None, description="LoginSessionID is the login session ID. If the user-agent reuses a login session (via cookie / remember flag) this ID will remain the same. If the user-agent did not have an existing authentication session (e.g. remember is false) this will be a new random value. This value is used as the \"sid\" parameter in the ID Token and in OIDC Front-/Back- channel logout. It's value can generally be used to associate consecutive login requests by a certain user.")
+    oidc_context: Optional[OAuth2ConsentRequestOpenIDConnectContext] = None
+    request_url: Optional[StrictStr] = Field(default=None, description="RequestURL is the original OAuth 2.0 Authorization URL requested by the OAuth 2.0 client. It is the URL which initiates the OAuth 2.0 Authorization Code or OAuth 2.0 Implicit flow. This URL is typically not needed, but might come in handy if you want to deal with additional request parameters.")
+    requested_access_token_audience: Optional[List[StrictStr]] = None
+    requested_scope: Optional[List[StrictStr]] = None
+    skip: Optional[StrictBool] = Field(default=None, description="Skip, if true, implies that the client has requested the same scopes from the same user previously. If true, you must not ask the user to grant the requested scopes. You must however either allow or deny the consent request using the usual API call.")
+    subject: Optional[StrictStr] = Field(default=None, description="Subject is the user ID of the end-user that authenticated. Now, that end user needs to grant or deny the scope requested by the OAuth 2.0 client.")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["acr", "amr", "challenge", "client", "context", "login_challenge", "login_session_id", "oidc_context", "request_url", "requested_access_token_audience", "requested_scope", "skip", "subject"]
+
+    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 OAuth2ConsentRequest 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.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of client
+        if self.client:
+            _dict['client'] = self.client.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of oidc_context
+        if self.oidc_context:
+            _dict['oidc_context'] = self.oidc_context.to_dict()
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OAuth2ConsentRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "acr": obj.get("acr"),
+            "amr": obj.get("amr"),
+            "challenge": obj.get("challenge"),
+            "client": OAuth2Client.from_dict(obj["client"]) if obj.get("client") is not None else None,
+            "context": obj.get("context"),
+            "login_challenge": obj.get("login_challenge"),
+            "login_session_id": obj.get("login_session_id"),
+            "oidc_context": OAuth2ConsentRequestOpenIDConnectContext.from_dict(obj["oidc_context"]) if obj.get("oidc_context") is not None else None,
+            "request_url": obj.get("request_url"),
+            "requested_access_token_audience": obj.get("requested_access_token_audience"),
+            "requested_scope": obj.get("requested_scope"),
+            "skip": obj.get("skip"),
+            "subject": obj.get("subject")
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

ory_client/models/o_auth2_consent_request_open_id_connect_context.py

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+"""
+    Ory APIs
+
+    Documentation for all public and administrative Ory APIs. Administrative APIs can only be accessed with a valid Personal Access Token. Public APIs are mostly used in browsers. 
+
+    The version of the OpenAPI document: v1.11.6
+    Contact: support@ory.sh
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OAuth2ConsentRequestOpenIDConnectContext(BaseModel):
+    """
+    OAuth2ConsentRequestOpenIDConnectContext
+    """ # noqa: E501
+    acr_values: Optional[List[StrictStr]] = Field(default=None, description="ACRValues is the Authentication AuthorizationContext Class Reference requested in the OAuth 2.0 Authorization request. It is a parameter defined by OpenID Connect and expresses which level of authentication (e.g. 2FA) is required.  OpenID Connect defines it as follows: > Requested Authentication AuthorizationContext Class Reference values. Space-separated string that specifies the acr values that the Authorization Server is being requested to use for processing this Authentication Request, with the values appearing in order of preference. The Authentication AuthorizationContext Class satisfied by the authentication performed is returned as the acr Claim Value, as specified in Section 2. The acr Claim is requested as a Voluntary Claim by this parameter.")
+    display: Optional[StrictStr] = Field(default=None, description="Display is a string value that specifies how the Authorization Server displays the authentication and consent user interface pages to the End-User. The defined values are: page: The Authorization Server SHOULD display the authentication and consent UI consistent with a full User Agent page view. If the display parameter is not specified, this is the default display mode. popup: The Authorization Server SHOULD display the authentication and consent UI consistent with a popup User Agent window. The popup User Agent window should be of an appropriate size for a login-focused dialog and should not obscure the entire window that it is popping up over. touch: The Authorization Server SHOULD display the authentication and consent UI consistent with a device that leverages a touch interface. wap: The Authorization Server SHOULD display the authentication and consent UI consistent with a \"feature phone\" type display.  The Authorization Server MAY also attempt to detect the capabilities of the User Agent and present an appropriate display.")
+    id_token_hint_claims: Optional[Dict[str, Any]] = Field(default=None, description="IDTokenHintClaims are the claims of the ID Token previously issued by the Authorization Server being passed as a hint about the End-User's current or past authenticated session with the Client.")
+    login_hint: Optional[StrictStr] = Field(default=None, description="LoginHint hints about the login identifier the End-User might use to log in (if necessary). This hint can be used by an RP if it first asks the End-User for their e-mail address (or other identifier) and then wants to pass that value as a hint to the discovered authorization service. This value MAY also be a phone number in the format specified for the phone_number Claim. The use of this parameter is optional.")
+    ui_locales: Optional[List[StrictStr]] = Field(default=None, description="UILocales is the End-User'id preferred languages and scripts for the user interface, represented as a space-separated list of BCP47 [RFC5646] language tag values, ordered by preference. For instance, the value \"fr-CA fr en\" represents a preference for French as spoken in Canada, then French (without a region designation), followed by English (without a region designation). An error SHOULD NOT result if some or all of the requested locales are not supported by the OpenID Provider.")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["acr_values", "display", "id_token_hint_claims", "login_hint", "ui_locales"]
+
+    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 OAuth2ConsentRequestOpenIDConnectContext 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.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OAuth2ConsentRequestOpenIDConnectContext from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "acr_values": obj.get("acr_values"),
+            "display": obj.get("display"),
+            "id_token_hint_claims": obj.get("id_token_hint_claims"),
+            "login_hint": obj.get("login_hint"),
+            "ui_locales": obj.get("ui_locales")
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

ory_client/models/o_auth2_consent_session.py

@@ -0,0 +1,130 @@
+# coding: utf-8
+
+"""
+    Ory APIs
+
+    Documentation for all public and administrative Ory APIs. Administrative APIs can only be accessed with a valid Personal Access Token. Public APIs are mostly used in browsers. 
+
+    The version of the OpenAPI document: v1.11.6
+    Contact: support@ory.sh
+    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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from ory_client.models.accept_o_auth2_consent_request_session import AcceptOAuth2ConsentRequestSession
+from ory_client.models.o_auth2_consent_request import OAuth2ConsentRequest
+from ory_client.models.o_auth2_consent_session_expires_at import OAuth2ConsentSessionExpiresAt
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OAuth2ConsentSession(BaseModel):
+    """
+    A completed OAuth 2.0 Consent Session.
+    """ # noqa: E501
+    consent_request: Optional[OAuth2ConsentRequest] = None
+    context: Optional[Dict[str, Any]] = None
+    expires_at: Optional[OAuth2ConsentSessionExpiresAt] = None
+    grant_access_token_audience: Optional[List[StrictStr]] = None
+    grant_scope: Optional[List[StrictStr]] = None
+    handled_at: Optional[datetime] = None
+    remember: Optional[StrictBool] = Field(default=None, description="Remember Consent  Remember, if set to true, tells ORY Hydra to remember this consent authorization and reuse it if the same client asks the same user for the same, or a subset of, scope.")
+    remember_for: Optional[StrictInt] = Field(default=None, description="Remember Consent For  RememberFor sets how long the consent authorization should be remembered for in seconds. If set to `0`, the authorization will be remembered indefinitely.")
+    session: Optional[AcceptOAuth2ConsentRequestSession] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["consent_request", "context", "expires_at", "grant_access_token_audience", "grant_scope", "handled_at", "remember", "remember_for", "session"]
+
+    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 OAuth2ConsentSession 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.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of consent_request
+        if self.consent_request:
+            _dict['consent_request'] = self.consent_request.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of expires_at
+        if self.expires_at:
+            _dict['expires_at'] = self.expires_at.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of session
+        if self.session:
+            _dict['session'] = self.session.to_dict()
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OAuth2ConsentSession from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "consent_request": OAuth2ConsentRequest.from_dict(obj["consent_request"]) if obj.get("consent_request") is not None else None,
+            "context": obj.get("context"),
+            "expires_at": OAuth2ConsentSessionExpiresAt.from_dict(obj["expires_at"]) if obj.get("expires_at") is not None else None,
+            "grant_access_token_audience": obj.get("grant_access_token_audience"),
+            "grant_scope": obj.get("grant_scope"),
+            "handled_at": obj.get("handled_at"),
+            "remember": obj.get("remember"),
+            "remember_for": obj.get("remember_for"),
+            "session": AcceptOAuth2ConsentRequestSession.from_dict(obj["session"]) if obj.get("session") is not None else None
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+