authlete_ruby_test 0.0.1.beta

data/lib/authlete/models/components/client.rbi

@@ -0,0 +1,219 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class Authlete::Models::Components::Client
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class Authlete::Models::Components::Client
+  def number(); end
+  def number=(str_); end
+  def service_number(); end
+  def service_number=(str_); end
+  def client_name(); end
+  def client_name=(str_); end
+  def client_names(); end
+  def client_names=(str_); end
+  def description(); end
+  def description=(str_); end
+  def descriptions(); end
+  def descriptions=(str_); end
+  def client_id(); end
+  def client_id=(str_); end
+  def client_secret(); end
+  def client_secret=(str_); end
+  def client_id_alias(); end
+  def client_id_alias=(str_); end
+  def client_id_alias_enabled(); end
+  def client_id_alias_enabled=(str_); end
+  def client_type(); end
+  def client_type=(str_); end
+  def application_type(); end
+  def application_type=(str_); end
+  def logo_uri(); end
+  def logo_uri=(str_); end
+  def logo_uris(); end
+  def logo_uris=(str_); end
+  def contacts(); end
+  def contacts=(str_); end
+  def tls_client_certificate_bound_access_tokens(); end
+  def tls_client_certificate_bound_access_tokens=(str_); end
+  def dynamically_registered(); end
+  def dynamically_registered=(str_); end
+  def software_id(); end
+  def software_id=(str_); end
+  def developer(); end
+  def developer=(str_); end
+  def software_version(); end
+  def software_version=(str_); end
+  def registration_access_token_hash(); end
+  def registration_access_token_hash=(str_); end
+  def created_at(); end
+  def created_at=(str_); end
+  def modified_at(); end
+  def modified_at=(str_); end
+  def grant_types(); end
+  def grant_types=(str_); end
+  def response_types(); end
+  def response_types=(str_); end
+  def redirect_uris(); end
+  def redirect_uris=(str_); end
+  def token_auth_method(); end
+  def token_auth_method=(str_); end
+  def self_signed_certificate_key_id(); end
+  def self_signed_certificate_key_id=(str_); end
+  def tls_client_auth_subject_dn(); end
+  def tls_client_auth_subject_dn=(str_); end
+  def tls_client_auth_san_dns(); end
+  def tls_client_auth_san_dns=(str_); end
+  def tls_client_auth_san_uri(); end
+  def tls_client_auth_san_uri=(str_); end
+  def tls_client_auth_san_ip(); end
+  def tls_client_auth_san_ip=(str_); end
+  def tls_client_auth_san_email(); end
+  def tls_client_auth_san_email=(str_); end
+  def par_required(); end
+  def par_required=(str_); end
+  def request_object_required(); end
+  def request_object_required=(str_); end
+  def request_uris(); end
+  def request_uris=(str_); end
+  def default_max_age(); end
+  def default_max_age=(str_); end
+  def default_acrs(); end
+  def default_acrs=(str_); end
+  def auth_time_required(); end
+  def auth_time_required=(str_); end
+  def subject_type(); end
+  def subject_type=(str_); end
+  def sector_identifier_uri(); end
+  def sector_identifier_uri=(str_); end
+  def derived_sector_identifier(); end
+  def derived_sector_identifier=(str_); end
+  def jwks_uri(); end
+  def jwks_uri=(str_); end
+  def jwks(); end
+  def jwks=(str_); end
+  def login_uri(); end
+  def login_uri=(str_); end
+  def tos_uri(); end
+  def tos_uri=(str_); end
+  def tos_uris(); end
+  def tos_uris=(str_); end
+  def policy_uri(); end
+  def policy_uri=(str_); end
+  def policy_uris(); end
+  def policy_uris=(str_); end
+  def client_uri(); end
+  def client_uri=(str_); end
+  def client_uris(); end
+  def client_uris=(str_); end
+  def bc_delivery_mode(); end
+  def bc_delivery_mode=(str_); end
+  def bc_notification_endpoint(); end
+  def bc_notification_endpoint=(str_); end
+  def bc_user_code_required(); end
+  def bc_user_code_required=(str_); end
+  def attributes(); end
+  def attributes=(str_); end
+  def extension(); end
+  def extension=(str_); end
+  def authorization_details_types(); end
+  def authorization_details_types=(str_); end
+  def custom_metadata(); end
+  def custom_metadata=(str_); end
+  def front_channel_request_object_encryption_required(); end
+  def front_channel_request_object_encryption_required=(str_); end
+  def request_object_encryption_alg_match_required(); end
+  def request_object_encryption_alg_match_required=(str_); end
+  def request_object_encryption_enc_match_required(); end
+  def request_object_encryption_enc_match_required=(str_); end
+  def digest_algorithm(); end
+  def digest_algorithm=(str_); end
+  def single_access_token_per_subject(); end
+  def single_access_token_per_subject=(str_); end
+  def pkce_required(); end
+  def pkce_required=(str_); end
+  def pkce_s256_required(); end
+  def pkce_s256_required=(str_); end
+  def dpop_required(); end
+  def dpop_required=(str_); end
+  def automatically_registered(); end
+  def automatically_registered=(str_); end
+  def explicitly_registered(); end
+  def explicitly_registered=(str_); end
+  def rs_request_signed(); end
+  def rs_request_signed=(str_); end
+  def rs_signed_request_key_id(); end
+  def rs_signed_request_key_id=(str_); end
+  def client_registration_types(); end
+  def client_registration_types=(str_); end
+  def organization_name(); end
+  def organization_name=(str_); end
+  def signed_jwks_uri(); end
+  def signed_jwks_uri=(str_); end
+  def entity_id(); end
+  def entity_id=(str_); end
+  def trust_anchor_id(); end
+  def trust_anchor_id=(str_); end
+  def trust_chain(); end
+  def trust_chain=(str_); end
+  def trust_chain_expires_at(); end
+  def trust_chain_expires_at=(str_); end
+  def trust_chain_updated_at(); end
+  def trust_chain_updated_at=(str_); end
+  def locked(); end
+  def locked=(str_); end
+  def credential_offer_endpoint(); end
+  def credential_offer_endpoint=(str_); end
+  def fapi_modes(); end
+  def fapi_modes=(str_); end
+  def response_modes(); end
+  def response_modes=(str_); end
+  def credential_response_encryption_required(); end
+  def credential_response_encryption_required=(str_); end
+  def mtls_endpoint_aliases_used(); end
+  def mtls_endpoint_aliases_used=(str_); end
+  def in_scope_for_token_migration(); end
+  def in_scope_for_token_migration=(str_); end
+  def metadata_document_location(); end
+  def metadata_document_location=(str_); end
+  def metadata_document_expires_at(); end
+  def metadata_document_expires_at=(str_); end
+  def metadata_document_updated_at(); end
+  def metadata_document_updated_at=(str_); end
+  def discovered_by_metadata_document(); end
+  def discovered_by_metadata_document=(str_); end
+  def client_source(); end
+  def client_source=(str_); end
+  def authorization_sign_alg(); end
+  def authorization_sign_alg=(str_); end
+  def authorization_encryption_alg(); end
+  def authorization_encryption_alg=(str_); end
+  def authorization_encryption_enc(); end
+  def authorization_encryption_enc=(str_); end
+  def token_auth_sign_alg(); end
+  def token_auth_sign_alg=(str_); end
+  def request_sign_alg(); end
+  def request_sign_alg=(str_); end
+  def request_encryption_alg(); end
+  def request_encryption_alg=(str_); end
+  def request_encryption_enc(); end
+  def request_encryption_enc=(str_); end
+  def id_token_sign_alg(); end
+  def id_token_sign_alg=(str_); end
+  def id_token_encryption_alg(); end
+  def id_token_encryption_alg=(str_); end
+  def id_token_encryption_enc(); end
+  def id_token_encryption_enc=(str_); end
+  def user_info_sign_alg(); end
+  def user_info_sign_alg=(str_); end
+  def user_info_encryption_alg(); end
+  def user_info_encryption_alg=(str_); end
+  def user_info_encryption_enc(); end
+  def user_info_encryption_enc=(str_); end
+  def bc_request_sign_alg(); end
+  def bc_request_sign_alg=(str_); end
+end

data/lib/authlete/models/components/client_auth_method.rb

@@ -0,0 +1,31 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module Authlete
+  module Models
+    module Components
+    
+      # ClientAuthMethod - The client authentication method that the client application declares that it uses at the token
+      # endpoint. This property corresponds to `token_endpoint_auth_method` in [OpenID Connect Dynamic
+      # Client Registration 1.0, 2. Client Metadata](https://openid.net/specs/openid-connect-registration-1_0.html#ClientMetadata).
+      # 
+      class ClientAuthMethod < T::Enum
+
+
+        enums do
+          NONE = new('NONE')
+          CLIENT_SECRET_BASIC = new('CLIENT_SECRET_BASIC')
+          CLIENT_SECRET_POST = new('CLIENT_SECRET_POST')
+          CLIENT_SECRET_JWT = new('CLIENT_SECRET_JWT')
+          PRIVATE_KEY_JWT = new('PRIVATE_KEY_JWT')
+          TLS_CLIENT_AUTH = new('TLS_CLIENT_AUTH')
+          SELF_SIGNED_TLS_CLIENT_AUTH = new('SELF_SIGNED_TLS_CLIENT_AUTH')
+          ATTEST_JWT_CLIENT_AUTH = new('ATTEST_JWT_CLIENT_AUTH')
+        end
+      end
+    end
+  end
+end

data/lib/authlete/models/components/client_auth_method.rbi

@@ -0,0 +1,11 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class Authlete::Models::Components::ClientAuthMethod
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class Authlete::Models::Components::ClientAuthMethod
+end

data/lib/authlete/models/components/client_authorization_delete_response.rb

@@ -0,0 +1,71 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module Authlete
+  module Models
+    module Components
+    
+
+      class ClientAuthorizationDeleteResponse
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The code which represents the result of the API call.
+        field :result_code, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('resultCode') } }
+        # A short message which explains the result of the API call.
+        field :result_message, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('resultMessage') } }
+        # A short message which explains the result of the API call.
+        field :service_api_key, Crystalline::Nilable.new(::Integer), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('serviceApiKey') } }
+        # Get the client ID.
+        field :client_id, Crystalline::Nilable.new(::Integer), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('clientId') } }
+        # Get the subject (= unique identifier) of the user
+        # who has granted authorization to the client.
+        # 
+        field :subject, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('subject') } }
+        # Get the scopes granted to the client application by the last
+        # authorization process by the user (who is identified by the
+        # subject).
+        # 
+        field :latest_granted_scopes, Crystalline::Nilable.new(Crystalline::Array.new(::String)), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('latestGrantedScopes') } }
+        # Get the scopes granted to the client application by all the
+        # past authorization processes. Note that revoked scopes are
+        # not included.
+        # 
+        field :merged_granted_scopes, Crystalline::Nilable.new(Crystalline::Array.new(::String)), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('mergedGrantedScopes') } }
+        # Get the timestamp in milliseconds since Unix epoch
+        # at which this record was modified.
+        # 
+        field :modified_at, Crystalline::Nilable.new(::Integer), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('modifiedAt') } }
+
+        sig { params(result_code: T.nilable(::String), result_message: T.nilable(::String), service_api_key: T.nilable(::Integer), client_id: T.nilable(::Integer), subject: T.nilable(::String), latest_granted_scopes: T.nilable(T::Array[::String]), merged_granted_scopes: T.nilable(T::Array[::String]), modified_at: T.nilable(::Integer)).void }
+        def initialize(result_code: nil, result_message: nil, service_api_key: nil, client_id: nil, subject: nil, latest_granted_scopes: nil, merged_granted_scopes: nil, modified_at: nil)
+          @result_code = result_code
+          @result_message = result_message
+          @service_api_key = service_api_key
+          @client_id = client_id
+          @subject = subject
+          @latest_granted_scopes = latest_granted_scopes
+          @merged_granted_scopes = merged_granted_scopes
+          @modified_at = modified_at
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @result_code == other.result_code
+          return false unless @result_message == other.result_message
+          return false unless @service_api_key == other.service_api_key
+          return false unless @client_id == other.client_id
+          return false unless @subject == other.subject
+          return false unless @latest_granted_scopes == other.latest_granted_scopes
+          return false unless @merged_granted_scopes == other.merged_granted_scopes
+          return false unless @modified_at == other.modified_at
+          true
+        end
+      end
+    end
+  end
+end

data/lib/authlete/models/components/client_authorization_delete_response.rbi

@@ -0,0 +1,27 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class Authlete::Models::Components::ClientAuthorizationDeleteResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class Authlete::Models::Components::ClientAuthorizationDeleteResponse
+  def result_code(); end
+  def result_code=(str_); end
+  def result_message(); end
+  def result_message=(str_); end
+  def service_api_key(); end
+  def service_api_key=(str_); end
+  def client_id(); end
+  def client_id=(str_); end
+  def subject(); end
+  def subject=(str_); end
+  def latest_granted_scopes(); end
+  def latest_granted_scopes=(str_); end
+  def merged_granted_scopes(); end
+  def merged_granted_scopes=(str_); end
+  def modified_at(); end
+  def modified_at=(str_); end
+end

data/lib/authlete/models/components/client_authorization_get_list_response.rb

@@ -0,0 +1,59 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module Authlete
+  module Models
+    module Components
+    
+
+      class ClientAuthorizationGetListResponse
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Start index of search results (inclusive).
+        # 
+        field :start, Crystalline::Nilable.new(::Integer), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('start') } }
+        # End index of search results (exclusive).
+        # 
+        field :end_, Crystalline::Nilable.new(::Integer), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('end') } }
+        # Unique ID of a client developer.
+        # 
+        field :developer, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('developer') } }
+        # Unique user ID of an end-user.
+        # 
+        field :subject, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('subject') } }
+        # Unique ID of a client developer.
+        # 
+        field :total_count, Crystalline::Nilable.new(::Integer), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('totalCount') } }
+        # An array of clients.
+        # 
+        field :clients, Crystalline::Nilable.new(Crystalline::Array.new(Models::Components::ClientLimited)), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('clients') } }
+
+        sig { params(start: T.nilable(::Integer), end_: T.nilable(::Integer), developer: T.nilable(::String), subject: T.nilable(::String), total_count: T.nilable(::Integer), clients: T.nilable(T::Array[Models::Components::ClientLimited])).void }
+        def initialize(start: nil, end_: nil, developer: nil, subject: nil, total_count: nil, clients: nil)
+          @start = start
+          @end_ = end_
+          @developer = developer
+          @subject = subject
+          @total_count = total_count
+          @clients = clients
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @start == other.start
+          return false unless @end_ == other.end_
+          return false unless @developer == other.developer
+          return false unless @subject == other.subject
+          return false unless @total_count == other.total_count
+          return false unless @clients == other.clients
+          true
+        end
+      end
+    end
+  end
+end

data/lib/authlete/models/components/client_authorization_get_list_response.rbi

@@ -0,0 +1,23 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class Authlete::Models::Components::ClientAuthorizationGetListResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class Authlete::Models::Components::ClientAuthorizationGetListResponse
+  def start(); end
+  def start=(str_); end
+  def end_(); end
+  def end_=(str_); end
+  def developer(); end
+  def developer=(str_); end
+  def subject(); end
+  def subject=(str_); end
+  def total_count(); end
+  def total_count=(str_); end
+  def clients(); end
+  def clients=(str_); end
+end

data/lib/authlete/models/components/client_authorization_update_request.rb

@@ -0,0 +1,43 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module Authlete
+  module Models
+    module Components
+    
+
+      class ClientAuthorizationUpdateRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The subject (= unique identifier) of the end-user who has granted authorization to the client
+        # application.
+        # 
+        field :subject, ::String, { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('subject'), required: true }, 'form': { 'field_name': 'subject' } }
+        # An array of new scopes. Optional. If a non-null value is given, the new scopes are set to all
+        # existing access tokens. If an API call is made using `"Content-Type: application/x-www-form-urlencoded"`,
+        # scope names listed in this request parameter should be delimited by spaces (after form encoding,
+        # spaces are converted to `+`).
+        # 
+        field :scopes, Crystalline::Nilable.new(Crystalline::Array.new(::String)), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('scopes') }, 'form': { 'field_name': 'scopes' } }
+
+        sig { params(subject: ::String, scopes: T.nilable(T::Array[::String])).void }
+        def initialize(subject:, scopes: nil)
+          @subject = subject
+          @scopes = scopes
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @subject == other.subject
+          return false unless @scopes == other.scopes
+          true
+        end
+      end
+    end
+  end
+end

data/lib/authlete/models/components/client_authorization_update_request.rbi

@@ -0,0 +1,15 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class Authlete::Models::Components::ClientAuthorizationUpdateRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class Authlete::Models::Components::ClientAuthorizationUpdateRequest
+  def subject(); end
+  def subject=(str_); end
+  def scopes(); end
+  def scopes=(str_); end
+end

data/lib/authlete/models/components/client_authorization_update_response.rb

@@ -0,0 +1,37 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module Authlete
+  module Models
+    module Components
+    
+
+      class ClientAuthorizationUpdateResponse
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The code which represents the result of the API call.
+        field :result_code, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('resultCode') } }
+        # A short message which explains the result of the API call.
+        field :result_message, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('resultMessage') } }
+
+        sig { params(result_code: T.nilable(::String), result_message: T.nilable(::String)).void }
+        def initialize(result_code: nil, result_message: nil)
+          @result_code = result_code
+          @result_message = result_message
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @result_code == other.result_code
+          return false unless @result_message == other.result_message
+          true
+        end
+      end
+    end
+  end
+end

data/lib/authlete/models/components/client_authorization_update_response.rbi

@@ -0,0 +1,15 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class Authlete::Models::Components::ClientAuthorizationUpdateResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class Authlete::Models::Components::ClientAuthorizationUpdateResponse
+  def result_code(); end
+  def result_code=(str_); end
+  def result_message(); end
+  def result_message=(str_); end
+end

data/lib/authlete/models/components/client_extension.rb

@@ -0,0 +1,94 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module Authlete
+  module Models
+    module Components
+    
+
+      class ClientExtension
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The set of scopes that the client application is allowed to request. This paramter will be one
+        # of the following.
+        # 
+        #   - `null`
+        #   - an empty set
+        #   - a set with at least one element
+        # 
+        # When the value of this parameter is `null`, it means that the set of scopes that the client
+        # application is allowed to request is the set of the scopes that the service supports. When the
+        # value of this parameter is an empty set, it means that the client application is not allowed to
+        # request any scopes. When the value of this parameter is a set with at least one element, it means
+        # that the set is the set of scopes that the client application is allowed to request.
+        # 
+        field :requestable_scopes, Crystalline::Nilable.new(Crystalline::Array.new(::String)), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('requestableScopes') } }
+        # The flag to indicate whether "Requestable Scopes per Client" is enabled or not. If `true`, you
+        # can define the set of scopes which this client application can request. If `false`, this client
+        # application can request any scope which is supported by the authorization server.
+        # 
+        field :requestable_scopes_enabled, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('requestableScopesEnabled') } }
+        # The value of the duration of access tokens per client in seconds. In normal cases, the value of
+        # the service's `accessTokenDuration` property is used as the duration of access tokens issued by
+        # the service. However, if this `accessTokenDuration` property holds a non-zero positive number
+        # and its value is less than the duration configured by the service, the value is used as the duration
+        # of access tokens issued to the client application.
+        # 
+        # Note that the duration of access tokens can be controlled by the scope attribute `access_token.duration`,
+        # too. Authlete chooses the minimum value among the candidates.
+        # 
+        field :access_token_duration, Crystalline::Nilable.new(::Integer), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('accessTokenDuration') } }
+        # The value of the duration of refresh tokens per client in seconds. In normal cases, the value
+        # of the service's `refreshTokenDuration` property is used as the duration of refresh tokens issued
+        # by the service. However, if this `refreshTokenDuration` property holds a non-zero positive number
+        # and its value is less than the duration configured by the service, the value is used as the duration
+        # of refresh tokens issued to the client application.
+        # 
+        # Note that the duration of refresh tokens can be controlled by the scope attribute `refresh_token.duration`,
+        # too. Authlete chooses the minimum value among the candidates.
+        # 
+        field :refresh_token_duration, Crystalline::Nilable.new(::Integer), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('refreshTokenDuration') } }
+        # The value of the duration of ID tokens per client in seconds. In normal cases, the value
+        # of the service's `idTokenDuration` property is used as the duration of ID tokens issued
+        # by the service. However, if this `idTokenDuration` property holds a non-zero positive number
+        # and its value is less than the duration configured by the service, the value is used as the duration
+        # of ID tokens issued to the client application.
+        # 
+        # Note that the duration of refresh tokens can be controlled by the scope attribute `id_token.duration`,
+        # too. Authlete chooses the minimum value among the candidates.
+        # 
+        field :id_token_duration, Crystalline::Nilable.new(::Integer), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('idTokenDuration') } }
+        # Get the flag indicating whether the client is explicitly given a
+        # permission to make token exchange requests ([RFC 8693][https://www.rfc-editor.org/rfc/rfc8693.html])
+        # 
+        field :token_exchange_permitted, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('tokenExchangePermitted') } }
+
+        sig { params(requestable_scopes: T.nilable(T::Array[::String]), requestable_scopes_enabled: T.nilable(T::Boolean), access_token_duration: T.nilable(::Integer), refresh_token_duration: T.nilable(::Integer), id_token_duration: T.nilable(::Integer), token_exchange_permitted: T.nilable(T::Boolean)).void }
+        def initialize(requestable_scopes: nil, requestable_scopes_enabled: nil, access_token_duration: nil, refresh_token_duration: nil, id_token_duration: nil, token_exchange_permitted: nil)
+          @requestable_scopes = requestable_scopes
+          @requestable_scopes_enabled = requestable_scopes_enabled
+          @access_token_duration = access_token_duration
+          @refresh_token_duration = refresh_token_duration
+          @id_token_duration = id_token_duration
+          @token_exchange_permitted = token_exchange_permitted
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @requestable_scopes == other.requestable_scopes
+          return false unless @requestable_scopes_enabled == other.requestable_scopes_enabled
+          return false unless @access_token_duration == other.access_token_duration
+          return false unless @refresh_token_duration == other.refresh_token_duration
+          return false unless @id_token_duration == other.id_token_duration
+          return false unless @token_exchange_permitted == other.token_exchange_permitted
+          true
+        end
+      end
+    end
+  end
+end

data/lib/authlete/models/components/client_extension.rbi

@@ -0,0 +1,23 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class Authlete::Models::Components::ClientExtension
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class Authlete::Models::Components::ClientExtension
+  def requestable_scopes(); end
+  def requestable_scopes=(str_); end
+  def requestable_scopes_enabled(); end
+  def requestable_scopes_enabled=(str_); end
+  def access_token_duration(); end
+  def access_token_duration=(str_); end
+  def refresh_token_duration(); end
+  def refresh_token_duration=(str_); end
+  def id_token_duration(); end
+  def id_token_duration=(str_); end
+  def token_exchange_permitted(); end
+  def token_exchange_permitted=(str_); end
+end