authlete_ruby_test 0.0.1.beta

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

@@ -0,0 +1,363 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class Authlete::Models::Components::ServiceInput
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class Authlete::Models::Components::ServiceInput
+  def service_name(); end
+  def service_name=(str_); end
+  def issuer(); end
+  def issuer=(str_); end
+  def description(); end
+  def description=(str_); end
+  def token_batch_notification_endpoint(); end
+  def token_batch_notification_endpoint=(str_); end
+  def client_assertion_aud_restricted_to_issuer(); end
+  def client_assertion_aud_restricted_to_issuer=(str_); end
+  def clients_per_developer(); end
+  def clients_per_developer=(str_); end
+  def developer_authentication_callback_endpoint(); end
+  def developer_authentication_callback_endpoint=(str_); end
+  def developer_authentication_callback_api_key(); end
+  def developer_authentication_callback_api_key=(str_); end
+  def developer_authentication_callback_api_secret(); end
+  def developer_authentication_callback_api_secret=(str_); end
+  def supported_snses(); end
+  def supported_snses=(str_); end
+  def sns_credentials(); end
+  def sns_credentials=(str_); end
+  def client_id_alias_enabled(); end
+  def client_id_alias_enabled=(str_); end
+  def metadata(); end
+  def metadata=(str_); end
+  def authentication_callback_endpoint(); end
+  def authentication_callback_endpoint=(str_); end
+  def authentication_callback_api_key(); end
+  def authentication_callback_api_key=(str_); end
+  def authentication_callback_api_secret(); end
+  def authentication_callback_api_secret=(str_); end
+  def supported_grant_types(); end
+  def supported_grant_types=(str_); end
+  def supported_response_types(); end
+  def supported_response_types=(str_); end
+  def supported_authorization_details_types(); end
+  def supported_authorization_details_types=(str_); end
+  def supported_service_profiles(); end
+  def supported_service_profiles=(str_); end
+  def error_description_omitted(); end
+  def error_description_omitted=(str_); end
+  def error_uri_omitted(); end
+  def error_uri_omitted=(str_); end
+  def authorization_endpoint(); end
+  def authorization_endpoint=(str_); end
+  def direct_authorization_endpoint_enabled(); end
+  def direct_authorization_endpoint_enabled=(str_); end
+  def supported_ui_locales(); end
+  def supported_ui_locales=(str_); end
+  def supported_displays(); end
+  def supported_displays=(str_); end
+  def pkce_required(); end
+  def pkce_required=(str_); end
+  def pkce_s256_required(); end
+  def pkce_s256_required=(str_); end
+  def authorization_response_duration(); end
+  def authorization_response_duration=(str_); end
+  def token_endpoint(); end
+  def token_endpoint=(str_); end
+  def direct_token_endpoint_enabled(); end
+  def direct_token_endpoint_enabled=(str_); end
+  def supported_token_auth_methods(); end
+  def supported_token_auth_methods=(str_); end
+  def missing_client_id_allowed(); end
+  def missing_client_id_allowed=(str_); end
+  def revocation_endpoint(); end
+  def revocation_endpoint=(str_); end
+  def direct_revocation_endpoint_enabled(); end
+  def direct_revocation_endpoint_enabled=(str_); end
+  def supported_revocation_auth_methods(); end
+  def supported_revocation_auth_methods=(str_); end
+  def introspection_endpoint(); end
+  def introspection_endpoint=(str_); end
+  def direct_introspection_endpoint_enabled(); end
+  def direct_introspection_endpoint_enabled=(str_); end
+  def supported_introspection_auth_methods(); end
+  def supported_introspection_auth_methods=(str_); end
+  def pushed_auth_req_endpoint(); end
+  def pushed_auth_req_endpoint=(str_); end
+  def pushed_auth_req_duration(); end
+  def pushed_auth_req_duration=(str_); end
+  def par_required(); end
+  def par_required=(str_); end
+  def request_object_required(); end
+  def request_object_required=(str_); end
+  def traditional_request_object_processing_applied(); end
+  def traditional_request_object_processing_applied=(str_); end
+  def mutual_tls_validate_pki_cert_chain(); end
+  def mutual_tls_validate_pki_cert_chain=(str_); end
+  def trusted_root_certificates(); end
+  def trusted_root_certificates=(str_); end
+  def mtls_endpoint_aliases(); end
+  def mtls_endpoint_aliases=(str_); end
+  def access_token_type(); end
+  def access_token_type=(str_); end
+  def tls_client_certificate_bound_access_tokens(); end
+  def tls_client_certificate_bound_access_tokens=(str_); end
+  def access_token_duration(); end
+  def access_token_duration=(str_); end
+  def single_access_token_per_subject(); end
+  def single_access_token_per_subject=(str_); end
+  def access_token_signature_key_id(); end
+  def access_token_signature_key_id=(str_); end
+  def refresh_token_duration(); end
+  def refresh_token_duration=(str_); end
+  def refresh_token_duration_kept(); end
+  def refresh_token_duration_kept=(str_); end
+  def refresh_token_duration_reset(); end
+  def refresh_token_duration_reset=(str_); end
+  def refresh_token_kept(); end
+  def refresh_token_kept=(str_); end
+  def supported_scopes(); end
+  def supported_scopes=(str_); end
+  def scope_required(); end
+  def scope_required=(str_); end
+  def id_token_duration(); end
+  def id_token_duration=(str_); end
+  def allowable_clock_skew(); end
+  def allowable_clock_skew=(str_); end
+  def supported_claim_types(); end
+  def supported_claim_types=(str_); end
+  def supported_claim_locales(); end
+  def supported_claim_locales=(str_); end
+  def supported_claims(); end
+  def supported_claims=(str_); end
+  def claim_shortcut_restrictive(); end
+  def claim_shortcut_restrictive=(str_); end
+  def jwks_uri(); end
+  def jwks_uri=(str_); end
+  def direct_jwks_endpoint_enabled(); end
+  def direct_jwks_endpoint_enabled=(str_); end
+  def jwks(); end
+  def jwks=(str_); end
+  def id_token_signature_key_id(); end
+  def id_token_signature_key_id=(str_); end
+  def user_info_signature_key_id(); end
+  def user_info_signature_key_id=(str_); end
+  def authorization_signature_key_id(); end
+  def authorization_signature_key_id=(str_); end
+  def user_info_endpoint(); end
+  def user_info_endpoint=(str_); end
+  def direct_user_info_endpoint_enabled(); end
+  def direct_user_info_endpoint_enabled=(str_); end
+  def dynamic_registration_supported(); end
+  def dynamic_registration_supported=(str_); end
+  def registration_endpoint(); end
+  def registration_endpoint=(str_); end
+  def registration_management_endpoint(); end
+  def registration_management_endpoint=(str_); end
+  def policy_uri(); end
+  def policy_uri=(str_); end
+  def tos_uri(); end
+  def tos_uri=(str_); end
+  def service_documentation(); end
+  def service_documentation=(str_); end
+  def backchannel_authentication_endpoint(); end
+  def backchannel_authentication_endpoint=(str_); end
+  def supported_backchannel_token_delivery_modes(); end
+  def supported_backchannel_token_delivery_modes=(str_); end
+  def backchannel_auth_req_id_duration(); end
+  def backchannel_auth_req_id_duration=(str_); end
+  def backchannel_polling_interval(); end
+  def backchannel_polling_interval=(str_); end
+  def backchannel_user_code_parameter_supported(); end
+  def backchannel_user_code_parameter_supported=(str_); end
+  def backchannel_binding_message_required_in_fapi(); end
+  def backchannel_binding_message_required_in_fapi=(str_); end
+  def device_authorization_endpoint(); end
+  def device_authorization_endpoint=(str_); end
+  def device_verification_uri(); end
+  def device_verification_uri=(str_); end
+  def device_verification_uri_complete(); end
+  def device_verification_uri_complete=(str_); end
+  def device_flow_code_duration(); end
+  def device_flow_code_duration=(str_); end
+  def device_flow_polling_interval(); end
+  def device_flow_polling_interval=(str_); end
+  def user_code_charset(); end
+  def user_code_charset=(str_); end
+  def user_code_length(); end
+  def user_code_length=(str_); end
+  def supported_trust_frameworks(); end
+  def supported_trust_frameworks=(str_); end
+  def supported_evidence(); end
+  def supported_evidence=(str_); end
+  def supported_identity_documents(); end
+  def supported_identity_documents=(str_); end
+  def supported_verification_methods(); end
+  def supported_verification_methods=(str_); end
+  def supported_verified_claims(); end
+  def supported_verified_claims=(str_); end
+  def verified_claims_validation_schema_set(); end
+  def verified_claims_validation_schema_set=(str_); end
+  def attributes(); end
+  def attributes=(str_); end
+  def nbf_optional(); end
+  def nbf_optional=(str_); end
+  def iss_suppressed(); end
+  def iss_suppressed=(str_); end
+  def supported_custom_client_metadata(); end
+  def supported_custom_client_metadata=(str_); end
+  def token_expiration_linked(); end
+  def token_expiration_linked=(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 hsm_enabled(); end
+  def hsm_enabled=(str_); end
+  def hsks(); end
+  def hsks=(str_); end
+  def grant_management_endpoint(); end
+  def grant_management_endpoint=(str_); end
+  def grant_management_action_required(); end
+  def grant_management_action_required=(str_); end
+  def unauthorized_on_client_config_supported(); end
+  def unauthorized_on_client_config_supported=(str_); end
+  def dcr_scope_used_as_requestable(); end
+  def dcr_scope_used_as_requestable=(str_); end
+  def end_session_endpoint(); end
+  def end_session_endpoint=(str_); end
+  def loopback_redirection_uri_variable(); end
+  def loopback_redirection_uri_variable=(str_); end
+  def request_object_audience_checked(); end
+  def request_object_audience_checked=(str_); end
+  def access_token_for_external_attachment_embedded(); end
+  def access_token_for_external_attachment_embedded=(str_); end
+  def authority_hints(); end
+  def authority_hints=(str_); end
+  def federation_enabled(); end
+  def federation_enabled=(str_); end
+  def federation_jwks(); end
+  def federation_jwks=(str_); end
+  def federation_signature_key_id(); end
+  def federation_signature_key_id=(str_); end
+  def federation_configuration_duration(); end
+  def federation_configuration_duration=(str_); end
+  def federation_registration_endpoint(); end
+  def federation_registration_endpoint=(str_); end
+  def organization_name(); end
+  def organization_name=(str_); end
+  def predefined_transformed_claims(); end
+  def predefined_transformed_claims=(str_); end
+  def refresh_token_idempotent(); end
+  def refresh_token_idempotent=(str_); end
+  def signed_jwks_uri(); end
+  def signed_jwks_uri=(str_); end
+  def supported_attachments(); end
+  def supported_attachments=(str_); end
+  def supported_digest_algorithms(); end
+  def supported_digest_algorithms=(str_); end
+  def supported_documents(); end
+  def supported_documents=(str_); end
+  def supported_documents_methods(); end
+  def supported_documents_methods=(str_); end
+  def supported_documents_validation_methods(); end
+  def supported_documents_validation_methods=(str_); end
+  def supported_documents_verification_methods(); end
+  def supported_documents_verification_methods=(str_); end
+  def supported_electronic_records(); end
+  def supported_electronic_records=(str_); end
+  def supported_client_registration_types(); end
+  def supported_client_registration_types=(str_); end
+  def token_exchange_by_identifiable_clients_only(); end
+  def token_exchange_by_identifiable_clients_only=(str_); end
+  def token_exchange_by_confidential_clients_only(); end
+  def token_exchange_by_confidential_clients_only=(str_); end
+  def token_exchange_by_permitted_clients_only(); end
+  def token_exchange_by_permitted_clients_only=(str_); end
+  def token_exchange_encrypted_jwt_rejected(); end
+  def token_exchange_encrypted_jwt_rejected=(str_); end
+  def token_exchange_unsigned_jwt_rejected(); end
+  def token_exchange_unsigned_jwt_rejected=(str_); end
+  def jwt_grant_by_identifiable_clients_only(); end
+  def jwt_grant_by_identifiable_clients_only=(str_); end
+  def jwt_grant_encrypted_jwt_rejected(); end
+  def jwt_grant_encrypted_jwt_rejected=(str_); end
+  def jwt_grant_unsigned_jwt_rejected(); end
+  def jwt_grant_unsigned_jwt_rejected=(str_); end
+  def dcr_duplicate_software_id_blocked(); end
+  def dcr_duplicate_software_id_blocked=(str_); end
+  def trust_anchors(); end
+  def trust_anchors=(str_); end
+  def openid_dropped_on_refresh_without_offline_access(); end
+  def openid_dropped_on_refresh_without_offline_access=(str_); end
+  def supported_documents_check_methods(); end
+  def supported_documents_check_methods=(str_); end
+  def rs_response_signed(); end
+  def rs_response_signed=(str_); end
+  def cnonce_duration(); end
+  def cnonce_duration=(str_); end
+  def dpop_nonce_required(); end
+  def dpop_nonce_required=(str_); end
+  def verifiable_credentials_enabled(); end
+  def verifiable_credentials_enabled=(str_); end
+  def credential_jwks_uri(); end
+  def credential_jwks_uri=(str_); end
+  def credential_offer_duration(); end
+  def credential_offer_duration=(str_); end
+  def dpop_nonce_duration(); end
+  def dpop_nonce_duration=(str_); end
+  def pre_authorized_grant_anonymous_access_supported(); end
+  def pre_authorized_grant_anonymous_access_supported=(str_); end
+  def credential_transaction_duration(); end
+  def credential_transaction_duration=(str_); end
+  def introspection_signature_key_id(); end
+  def introspection_signature_key_id=(str_); end
+  def resource_signature_key_id(); end
+  def resource_signature_key_id=(str_); end
+  def user_pin_length(); end
+  def user_pin_length=(str_); end
+  def supported_prompt_values(); end
+  def supported_prompt_values=(str_); end
+  def id_token_reissuable(); end
+  def id_token_reissuable=(str_); end
+  def credential_jwks(); end
+  def credential_jwks=(str_); end
+  def fapi_modes(); end
+  def fapi_modes=(str_); end
+  def credential_duration(); end
+  def credential_duration=(str_); end
+  def credential_issuer_metadata(); end
+  def credential_issuer_metadata=(str_); end
+  def id_token_aud_type(); end
+  def id_token_aud_type=(str_); end
+  def native_sso_supported(); end
+  def native_sso_supported=(str_); end
+  def oid4vci_version(); end
+  def oid4vci_version=(str_); end
+  def cimd_metadata_policy_enabled(); end
+  def cimd_metadata_policy_enabled=(str_); end
+  def client_id_metadata_document_supported(); end
+  def client_id_metadata_document_supported=(str_); end
+  def cimd_allowlist_enabled(); end
+  def cimd_allowlist_enabled=(str_); end
+  def cimd_allowlist(); end
+  def cimd_allowlist=(str_); end
+  def cimd_always_retrieved(); end
+  def cimd_always_retrieved=(str_); end
+  def cimd_http_permitted(); end
+  def cimd_http_permitted=(str_); end
+  def cimd_query_permitted(); end
+  def cimd_query_permitted=(str_); end
+  def cimd_metadata_policy(); end
+  def cimd_metadata_policy=(str_); end
+  def http_alias_prohibited(); end
+  def http_alias_prohibited=(str_); end
+  def access_token_sign_alg(); end
+  def access_token_sign_alg=(str_); end
+end

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

@@ -0,0 +1,33 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module Authlete
+  module Models
+    module Components
+    
+
+      class ServiceJwksGetResponse
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # An array of [JWK](https://datatracker.ietf.org/doc/html/rfc7517)s.
+        field :keys, Crystalline::Nilable.new(Crystalline::Array.new(Crystalline::Hash.new(Symbol, ::Object))), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('keys') } }
+
+        sig { params(keys: T.nilable(T::Array[T::Hash[Symbol, ::Object]])).void }
+        def initialize(keys: nil)
+          @keys = keys
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @keys == other.keys
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class Authlete::Models::Components::ServiceJwksGetResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class Authlete::Models::Components::ServiceJwksGetResponse
+  def keys(); end
+  def keys=(str_); end
+end

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

@@ -0,0 +1,22 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module Authlete
+  module Models
+    module Components
+    
+
+      class ServiceProfile < T::Enum
+
+
+        enums do
+          FAPI = new('FAPI')
+          OPEN_BANKING = new('OPEN_BANKING')
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,41 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module Authlete
+  module Models
+    module Components
+    
+
+      class SnsCredentials
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # SNS.
+        field :sns, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('sns') } }
+        # API key.
+        field :api_key, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('apiKey') } }
+        # API secret.
+        field :api_secret, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('apiSecret') } }
+
+        sig { params(sns: T.nilable(::String), api_key: T.nilable(::String), api_secret: T.nilable(::String)).void }
+        def initialize(sns: nil, api_key: nil, api_secret: nil)
+          @sns = sns
+          @api_key = api_key
+          @api_secret = api_secret
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @sns == other.sns
+          return false unless @api_key == other.api_key
+          return false unless @api_secret == other.api_secret
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class Authlete::Models::Components::SnsCredentials
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class Authlete::Models::Components::SnsCredentials
+  def sns(); end
+  def sns=(str_); end
+  def api_key(); end
+  def api_key=(str_); end
+  def api_secret(); end
+  def api_secret=(str_); end
+end

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

@@ -0,0 +1,129 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+
+module Authlete
+  module Models
+    module Components
+    
+
+      class StandardIntrospectionRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Request parameters which comply with the introspection request defined
+        # in "[2.1. Introspection Request](https://datatracker.ietf.org/doc/html/rfc7662#section-2.1)" in
+        # RFC 7662.
+        # 
+        # The implementation of the introspection endpoint of your authorization server will receive an
+        # HTTP POST [[RFC 7231](https://datatracker.ietf.org/doc/html/rfc7231)] request with parameters
+        # in the `application/x-www-form-urlencoded` format. It is the entity body of the request that
+        # Authlete's  `/api/auth/introspection/standard` API expects as the value of `parameters`.
+        # 
+        field :parameters, ::String, { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('parameters'), required: true }, 'form': { 'field_name': 'parameters' } }
+        # Flag indicating whether to include hidden properties in the output.
+        # 
+        # Authlete has a mechanism whereby to associate arbitrary key-value pairs with an access token.
+        # Each key-value pair has a hidden attribute. By default, key-value pairs whose hidden attribute
+        # is set to `true` are not embedded in the standard introspection output.
+        # 
+        # If the `withHiddenProperties` request parameter is given and its value is `true`, `/api/auth/introspection/standard
+        # API includes all the associated key-value pairs into the output regardless of the value of the
+        # hidden attribute.
+        # 
+        field :with_hidden_properties, Crystalline::Nilable.new(Crystalline::Boolean.new), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('withHiddenProperties') }, 'form': { 'field_name': 'withHiddenProperties' } }
+        # The URI of the resource server making the introspection request.
+        # 
+        # If the `rsUri` request parameter is given and the token has audience values, Authlete checks if
+        # the value of the `rsUri` request parameter is contained in the audience values. If not contained,
+        # Authlete generates an introspection response with the `active` property set to `false`.
+        # 
+        # The `rsUri` request parameter is required when the resource server requests a JWT introspection
+        # response, i.e., when the value of the `httpAcceptHeader` request parameter is set to `"application/token-introspection+jwt"`.
+        # 
+        field :rs_uri, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('rsUri') }, 'form': { 'field_name': 'rsUri' } }
+        # The value of the `HTTP Accept` header in the introspection request.
+        # 
+        # If the value of the `httpAcceptHeader` request parameter is `"application/token-introspection+jwt"`,
+        # Authlete generates a JWT introspection response. See "[4. Requesting a JWT Response](https://www.rfc-editor.org/rfc/rfc9701.html#section-4)"
+        # of "[RFC 9701: JWT Response for OAuth Token Introspection](https://www.rfc-editor.org/rfc/rfc9701.html)"
+        # for more details.
+        # 
+        field :http_accept_header, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('httpAcceptHeader') }, 'form': { 'field_name': 'httpAcceptHeader' } }
+        # The JWS `alg` algorithm for signing the introspection response. This parameter corresponds to
+        # `introspection_signed_response_alg` defined in "[6. Client Metadata](https://www.rfc-editor.org/rfc/rfc9701.html#section-6)"
+        # of "[RFC 9701: JWT Response for OAuth Token Introspection](https://www.rfc-editor.org/rfc/rfc9701.html)".
+        # 
+        # The default value is `RS256`.
+        # 
+        field :introspection_sign_alg, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('introspectionSignAlg') }, 'form': { 'field_name': 'introspectionSignAlg' } }
+        # The JWE `alg` algorithm for encrypting the introspection response. This parameter corresponds
+        # to `introspection_encrypted_response_alg` defined in "[6. Client Metadata](https://www.rfc-editor.org/rfc/rfc9701.html#section-6)"
+        # of "[RFC 9701: JWT Response for OAuth Token Introspection](https://www.rfc-editor.org/rfc/rfc9701.html)".
+        # 
+        # If the `introspectionEncryptionAlg` request parameter is specified, Authlete generates a JWT
+        # introspection response encrypted with the algorithm by this property and the algorithm specified by
+        # the `introspectionEncryptionEnc` request parameter.
+        # 
+        field :introspection_encryption_alg, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('introspectionEncryptionAlg') }, 'form': { 'field_name': 'introspectionEncryptionAlg' } }
+        # The JWE `enc` algorithm for encrypting the introspection response. This parameter corresponds
+        # to `introspection_encrypted_response_enc` defined in "[6. Client Metadata](https://www.rfc-editor.org/rfc/rfc9701.html#section-6)"
+        # of "[RFC 9701: JWT Response for OAuth Token Introspection](https://www.rfc-editor.org/rfc/rfc9701.html)".
+        # 
+        # The default value is `A128CBC_HS256`.
+        # 
+        field :introspection_encryption_enc, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('introspectionEncryptionEnc') }, 'form': { 'field_name': 'introspectionEncryptionEnc' } }
+        # The shared key for signing the introspection response with a symmetric algorithm.
+        # 
+        # The `sharedKeyForSign` request parameter is required when the introspection response is requested
+        # to be signed with a symmetric algorithm.
+        # 
+        field :shared_key_for_sign, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('sharedKeyForSign') }, 'form': { 'field_name': 'sharedKeyForSign' } }
+        # The shared key for encrypting the introspection response with a symmetric algorithm.
+        # 
+        # The `sharedKeyForEncryption` request parameter is required when the introspection response is
+        # requested to be encrypted with a symmetric algorithm.
+        # 
+        field :shared_key_for_encryption, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('sharedKeyForEncryption') }, 'form': { 'field_name': 'sharedKeyForEncryption' } }
+        # The public key for signing the introspection response with an asymmetric algorithm.
+        # 
+        # The `publicKeyForEncryption` request parameter is required when the introspection response is
+        # requested to be encrypted with an asymmetric algorithm.
+        # 
+        field :public_key_for_encryption, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Authlete::Utils.field_name('publicKeyForEncryption') }, 'form': { 'field_name': 'publicKeyForEncryption' } }
+
+        sig { params(parameters: ::String, with_hidden_properties: T.nilable(T::Boolean), rs_uri: T.nilable(::String), http_accept_header: T.nilable(::String), introspection_sign_alg: T.nilable(::String), introspection_encryption_alg: T.nilable(::String), introspection_encryption_enc: T.nilable(::String), shared_key_for_sign: T.nilable(::String), shared_key_for_encryption: T.nilable(::String), public_key_for_encryption: T.nilable(::String)).void }
+        def initialize(parameters:, with_hidden_properties: nil, rs_uri: nil, http_accept_header: nil, introspection_sign_alg: nil, introspection_encryption_alg: nil, introspection_encryption_enc: nil, shared_key_for_sign: nil, shared_key_for_encryption: nil, public_key_for_encryption: nil)
+          @parameters = parameters
+          @with_hidden_properties = with_hidden_properties
+          @rs_uri = rs_uri
+          @http_accept_header = http_accept_header
+          @introspection_sign_alg = introspection_sign_alg
+          @introspection_encryption_alg = introspection_encryption_alg
+          @introspection_encryption_enc = introspection_encryption_enc
+          @shared_key_for_sign = shared_key_for_sign
+          @shared_key_for_encryption = shared_key_for_encryption
+          @public_key_for_encryption = public_key_for_encryption
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a? self.class
+          return false unless @parameters == other.parameters
+          return false unless @with_hidden_properties == other.with_hidden_properties
+          return false unless @rs_uri == other.rs_uri
+          return false unless @http_accept_header == other.http_accept_header
+          return false unless @introspection_sign_alg == other.introspection_sign_alg
+          return false unless @introspection_encryption_alg == other.introspection_encryption_alg
+          return false unless @introspection_encryption_enc == other.introspection_encryption_enc
+          return false unless @shared_key_for_sign == other.shared_key_for_sign
+          return false unless @shared_key_for_encryption == other.shared_key_for_encryption
+          return false unless @public_key_for_encryption == other.public_key_for_encryption
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# typed: true
+# frozen_string_literal: true
+
+
+class Authlete::Models::Components::StandardIntrospectionRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+
+class Authlete::Models::Components::StandardIntrospectionRequest
+  def parameters(); end
+  def parameters=(str_); end
+  def with_hidden_properties(); end
+  def with_hidden_properties=(str_); end
+  def rs_uri(); end
+  def rs_uri=(str_); end
+  def http_accept_header(); end
+  def http_accept_header=(str_); end
+  def introspection_sign_alg(); end
+  def introspection_sign_alg=(str_); end
+  def introspection_encryption_alg(); end
+  def introspection_encryption_alg=(str_); end
+  def introspection_encryption_enc(); end
+  def introspection_encryption_enc=(str_); end
+  def shared_key_for_sign(); end
+  def shared_key_for_sign=(str_); end
+  def shared_key_for_encryption(); end
+  def shared_key_for_encryption=(str_); end
+  def public_key_for_encryption(); end
+  def public_key_for_encryption=(str_); end
+end