didit-sdk 1.0.0

data/lib/didit/resources/id_wallets.rb

@@ -0,0 +1,1468 @@
+# Code generated by codegen from openapi/*.json. DO NOT EDIT.
+# frozen_string_literal: true
+
+module Didit
+  module Resources
+    # The +id_wallets+ resource.
+    class IdWallets < Didit::Resource
+      # Cancel a wallet verification
+      #
+      # Withdraw a pending verification: it is declined as cancelled and never billed. A decided one is returned
+      # unchanged. Smart-ID and Mobile-ID: a cancel that arrives while a poll is checking the sign-in waits a few
+      # seconds for that poll, then declines it, or returns it verified if the user had already confirmed. A
+      # verification the user is completing right now cannot be cancelled (409 verification_in_progress with
+      # Retry-After): retry after that many seconds to read its outcome.
+      #
+      # +POST /v3/id-verification/wallets/verifications/{request_id}/cancel/+
+      #
+      # @param request_id [String] The request_id the start endpoint returned.
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def cancel_verification(request_id, request_options: nil)
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/verifications/{request_id}/cancel/",
+          path_params: { "request_id" => request_id },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # List Digital ID wallets
+      #
+      # Every Digital ID wallet with its start endpoint, countries, required fields and whether this application can
+      # start it in this environment now. Listed does not mean live.
+      #
+      # +GET /v3/id-verification/wallets/+
+      #
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletCatalogResponse]
+      def list(request_options: nil)
+        @client.request(
+          :get,
+          "/v3/id-verification/wallets/",
+          response: Types::DigitalIdWalletApiWalletCatalogResponse,
+          request_options: request_options
+        )
+      end
+
+      # Poll a wallet verification
+      #
+      # Smart-ID and Mobile-ID: ask the provider whether the user confirmed, refused or let the prompt lapse, and
+      # verify the signed identity when they confirmed. Redirect wallets complete through the user's browser, so for
+      # them this only reads the verification back. Answers the verification as it is afterwards.
+      #
+      # +POST /v3/id-verification/wallets/verifications/{request_id}/poll/+
+      #
+      # @param request_id [String] The request_id the start endpoint returned.
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def poll_verification(request_id, request_options: nil)
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/verifications/{request_id}/poll/",
+          path_params: { "request_id" => request_id },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Get a wallet verification
+      #
+      # Status and result of a wallet verification: the normalized identity and the wallet's own attributes once
+      # verified, the error code once declined, the next action while pending. A verification past expires_at is
+      # decided timeout.
+      #
+      # +GET /v3/id-verification/wallets/verifications/{request_id}/+
+      #
+      # @param request_id [String] The request_id the start endpoint returned.
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def retrieve_verification(request_id, request_options: nil)
+        @client.request(
+          :get,
+          "/v3/id-verification/wallets/verifications/{request_id}/",
+          path_params: { "request_id" => request_id },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start Auðkenni verification
+      #
+      # Start a Auðkenni sign-in (Auðkenni (Icelandic electronic ID); ISL) without any workflow. Billed once, only
+      # when the identity is verified. The response carries next_action.type=redirect with the URL to send the user's
+      # browser to; the user returns to return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/audkenni/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the Auðkenni identity. Defaults to ISL, the only country
+      #   it serves. * `ISL` - ISL
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_audkenni(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/audkenni/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start Bank iD verification
+      #
+      # Start a Bank iD sign-in (Bankovní identita, a.s.; CZE) without any workflow. Billed once, only when the
+      # identity is verified. The response carries next_action.type=redirect with the URL to send the user's browser
+      # to; the user returns to return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/bankid-cz/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the Bank iD identity. Defaults to CZE, the only country
+      #   it serves. * `CZE` - CZE
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_bankid_cz(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/bankid-cz/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start BankID (NOR) verification
+      #
+      # Start a BankID (NOR) sign-in (BankID BankAxept AS; NOR) without any workflow. Billed once, only when the
+      # identity is verified. The response carries next_action.type=redirect with the URL to send the user's browser
+      # to; the user returns to return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/bankid-no/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the BankID identity. Defaults to NOR, the only country
+      #   it serves. * `NOR` - NOR
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_bankid_no(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/bankid-no/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start BankID (SWE) verification
+      #
+      # Start a BankID (SWE) sign-in (Finansiell ID-Teknik / bank consortium; SWE) without any workflow. Billed once,
+      # only when the identity is verified. The response carries next_action.type=redirect with the URL to send the
+      # user's browser to; the user returns to return_url with request_id and result appended. Read the outcome with
+      # GET /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/bankid-se/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the BankID identity. Defaults to SWE, the only country
+      #   it serves. * `SWE` - SWE
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_bankid_se(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/bankid-se/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start Buypass ID verification
+      #
+      # Start a Buypass ID sign-in (Buypass AS; NOR) without any workflow. Billed once, only when the identity is
+      # verified. The response carries next_action.type=redirect with the URL to send the user's browser to; the user
+      # returns to return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/buypass/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the Buypass ID identity. Defaults to NOR, the only
+      #   country it serves. * `NOR` - NOR
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_buypass(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/buypass/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start ConnectID verification
+      #
+      # Start a ConnectID sign-in (Australian Payments Plus; AUS) without any workflow. Billed once, only when the
+      # identity is verified. The response carries next_action.type=redirect with the URL to send the user's browser
+      # to; the user returns to return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/connectid/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the ConnectID identity. Defaults to AUS, the only
+      #   country it serves. * `AUS` - AUS
+      # @param authorisation_server_id [String] Authorisation server ID selected with ConnectID's bank selector.
+      #   Sandbox defaults to Mock Bank A.
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_connectid(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        authorisation_server_id: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/connectid/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "authorisation_server_id" => authorisation_server_id,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start Diia verification
+      #
+      # Start a Diia sign-in (Ministry of Digital Transformation of Ukraine; UKR) without any workflow. Billed once,
+      # only when the identity is verified. The response carries next_action.type=redirect with the URL to send the
+      # user's browser to; the user returns to return_url with request_id and result appended. Read the outcome with
+      # GET /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/diia/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the Diia identity. Defaults to UKR, the only country it
+      #   serves. * `UKR` - UKR
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_diia(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/diia/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start eParaksts mobile verification
+      #
+      # Start a eParaksts mobile sign-in (LVRTC (Latvian State Radio and Television Centre); LVA) without any
+      # workflow. Billed once, only when the identity is verified. The response carries next_action.type=redirect with
+      # the URL to send the user's browser to; the user returns to return_url with request_id and result appended.
+      # Read the outcome with GET /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never
+      # from the URL. Sandbox applications get a deterministic simulation (simulated: true) that never contacts the
+      # provider.
+      #
+      # +POST /v3/id-verification/wallets/eparaksts-mobile/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the eParaksts mobile identity. Defaults to LVA, the only
+      #   country it serves. * `LVA` - LVA
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_eparaksts_mobile(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/eparaksts-mobile/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start EUDI Wallet verification
+      #
+      # Start a EUDI Wallet sign-in (The user's own member state; the issuer differs per country; AUT, BEL, BGR, HRV,
+      # CYP, CZE, DNK, EST, FIN, FRA, DEU, GRC, HUN, IRL, ITA, LVA, LTU, LUX, MLT, NLD, POL, PRT, ROU, SVK, SVN, ESP,
+      # SWE, ISL, LIE, NOR) without any workflow. Billed once, only when the identity is verified. The response
+      # carries next_action.type=redirect with the URL to send the user's browser to; the user returns to return_url
+      # with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/eudi/+
+      #
+      # @param country [String] ISO 3166-1 alpha-3 country of the EUDI Wallet identity. * `AUT` - AUT * `BEL` - BEL *
+      #   `BGR` - BGR * `HRV` - HRV * `CYP` - CYP * `CZE` - CZE * `DNK` - DNK * `EST` - EST * `FIN` - FIN * `FRA` - FRA
+      #   * `DEU` - DEU * `GRC` - GRC * `HUN` - HUN * `IRL` - IRL * `ITA` - ITA * `LVA` - LVA * `LTU` - LTU * `LUX` -
+      #   LUX * `MLT` - MLT * `NLD` - NLD * `POL` - POL * `PRT` - PRT * `ROU` - ROU * `SVK` - SVK * `SVN`...
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_eudi(
+        country:,
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/eudi/",
+          body: {
+            "country" => country,
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start FranceConnect verification
+      #
+      # Start a FranceConnect sign-in (DINUM (French state); FRA) without any workflow. Billed once, only when the
+      # identity is verified. The response carries next_action.type=redirect with the URL to send the user's browser
+      # to; the user returns to return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/franceconnect/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the FranceConnect identity. Defaults to FRA, the only
+      #   country it serves. * `FRA` - FRA
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_franceconnect(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/franceconnect/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start Freja eID verification
+      #
+      # Start a Freja eID sign-in (Freja eID Group; SWE) without any workflow. Billed once, only when the identity is
+      # verified. The response carries next_action.type=redirect with the URL to send the user's browser to; the user
+      # returns to return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/frejaid/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the Freja eID identity. Defaults to SWE, the only
+      #   country it serves. * `SWE` - SWE
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_frejaid(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/frejaid/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start Finnish Trust Network verification
+      #
+      # Start a Finnish Trust Network sign-in (Finnish banks and mobile operators (FTN); FIN) without any workflow.
+      # Billed once, only when the identity is verified. The response carries next_action.type=redirect with the URL
+      # to send the user's browser to; the user returns to return_url with request_id and result appended. Read the
+      # outcome with GET /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the
+      # URL. Sandbox applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/ftn/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the Finnish Trust Network identity. Defaults to FIN, the
+      #   only country it serves. * `FIN` - FIN
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_ftn(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/ftn/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start gov.br verification
+      #
+      # Start a gov.br sign-in (Governo Federal do Brasil; BRA) without any workflow. Billed once, only when the
+      # identity is verified. The response carries next_action.type=redirect with the URL to send the user's browser
+      # to; the user returns to return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/govbr/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the gov.br identity. Defaults to BRA, the only country
+      #   it serves. * `BRA` - BRA
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_govbr(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/govbr/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start GOV.UK Wallet verification
+      #
+      # Start a GOV.UK Wallet sign-in (UK Government Digital Service; GBR) without any workflow. Billed once, only
+      # when the identity is verified. The response carries next_action.type=redirect with the URL to send the user's
+      # browser to; the user returns to return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/govuk-wallet/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the GOV.UK Wallet identity. Defaults to GBR, the only
+      #   country it serves. * `GBR` - GBR
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_govuk_wallet(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/govuk-wallet/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start Estonian ID-card verification
+      #
+      # Start a Estonian ID-card sign-in (Police and Border Guard Board (Estonia); EST) without any workflow. Billed
+      # once, only when the identity is verified. The response carries next_action.type=redirect with the URL to send
+      # the user's browser to; the user returns to return_url with request_id and result appended. Read the outcome
+      # with GET /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL.
+      # Sandbox applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/idcard-ee/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the Estonian ID-card identity. Defaults to EST, the only
+      #   country it serves. * `EST` - EST
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_idcard_ee(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/idcard-ee/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start iDIN verification
+      #
+      # Start a iDIN sign-in (Dutch banks (Currence iDIN); NLD) without any workflow. Billed once, only when the
+      # identity is verified. The response carries next_action.type=redirect with the URL to send the user's browser
+      # to; the user returns to return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/idin/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the iDIN identity. Defaults to NLD, the only country it
+      #   serves. * `NLD` - NLD
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_idin(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/idin/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start itsme verification
+      #
+      # Start a itsme sign-in (Belgian Mobile ID; BEL, LUX, NLD) without any workflow. Billed once, only when the
+      # identity is verified. The response carries next_action.type=redirect with the URL to send the user's browser
+      # to; the user returns to return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/itsme/+
+      #
+      # @param country [String] ISO 3166-1 alpha-3 country of the itsme identity. * `BEL` - BEL * `LUX` - LUX * `NLD`
+      #   - NLD
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_itsme(
+        country:,
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/itsme/",
+          body: {
+            "country" => country,
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start MitID verification
+      #
+      # Start a MitID sign-in (Danish Agency for Digital Government; DNK) without any workflow. Billed once, only when
+      # the identity is verified. The response carries next_action.type=redirect with the URL to send the user's
+      # browser to; the user returns to return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/mitid/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the MitID identity. Defaults to DNK, the only country it
+      #   serves. * `DNK` - DNK
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_mitid(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/mitid/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start Mobile-ID verification
+      #
+      # Start a Mobile-ID sign-in (SK ID Solutions with the national mobile operators; EST, LTU) without any workflow.
+      # Billed once, only when the identity is verified. The response carries next_action.type=confirm_in_app with the
+      # comparison code to show the user; the user confirms it and enters their PIN in the app (never collect the
+      # PIN). Poll POST /v3/id-verification/wallets/verifications/{request_id}/poll/ every poll_interval_seconds, or
+      # rely on the webhook: Didit polls in the background too. Sandbox applications get a deterministic simulation
+      # (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/mobile-id/+
+      #
+      # @param country [String] ISO 3166-1 alpha-3 country of the Mobile-ID identity. * `EST` - EST * `LTU` - LTU
+      # @param personal_code [String] The user's national personal identification code. It addresses the user's
+      #   Mobile-ID app; the user confirms the comparison code and enters their PIN in the app. Never collect the PIN.
+      # @param phone_number [String] The Mobile-ID phone number in E.164 format (+372... or +370...).
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_mobile_id(
+        country:,
+        personal_code:,
+        phone_number:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/mobile-id/",
+          body: {
+            "country" => country,
+            "personal_code" => personal_code,
+            "phone_number" => phone_number,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start MojeID verification
+      #
+      # Start a MojeID sign-in (CZ.NIC; CZE) without any workflow. Billed once, only when the identity is verified.
+      # The response carries next_action.type=redirect with the URL to send the user's browser to; the user returns to
+      # return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/mojeid/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the MojeID identity. Defaults to CZE, the only country
+      #   it serves. * `CZE` - CZE
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_mojeid(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/mojeid/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start OneID verification
+      #
+      # Start a OneID sign-in (OneID (UK bank-verified identity); GBR) without any workflow. Billed once, only when
+      # the identity is verified. The response carries next_action.type=redirect with the URL to send the user's
+      # browser to; the user returns to return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/oneid/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the OneID identity. Defaults to GBR, the only country it
+      #   serves. * `GBR` - GBR
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_oneid(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/oneid/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start Personalausweis verification
+      #
+      # Start a Personalausweis sign-in (Bundesministerium des Innern (eID); DEU) without any workflow. Billed once,
+      # only when the identity is verified. The response carries next_action.type=redirect with the URL to send the
+      # user's browser to; the user returns to return_url with request_id and result appended. Read the outcome with
+      # GET /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/personalausweis/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the Personalausweis identity. Defaults to DEU, the only
+      #   country it serves. * `DEU` - DEU
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_personalausweis(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/personalausweis/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start Smart-ID verification
+      #
+      # Start a Smart-ID sign-in (SK ID Solutions; EST, LVA, LTU, BEL) without any workflow. Billed once, only when
+      # the identity is verified. The response carries next_action.type=confirm_in_app with the comparison code to
+      # show the user; the user confirms it and enters their PIN in the app (never collect the PIN). Poll POST
+      # /v3/id-verification/wallets/verifications/{request_id}/poll/ every poll_interval_seconds, or rely on the
+      # webhook: Didit polls in the background too. Sandbox applications get a deterministic simulation (simulated:
+      # true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/smart-id/+
+      #
+      # @param country [String] ISO 3166-1 alpha-3 country of the Smart-ID identity. * `EST` - EST * `LVA` - LVA *
+      #   `LTU` - LTU * `BEL` - BEL
+      # @param personal_code [String] The user's national personal identification code. It addresses the user's
+      #   Smart-ID app; the user confirms the comparison code and enters their PIN in the app. Never collect the PIN.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_smart_id(
+        country:,
+        personal_code:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/smart-id/",
+          body: {
+            "country" => country,
+            "personal_code" => personal_code,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start UAE PASS verification
+      #
+      # Start a UAE PASS sign-in (UAE Digital Government Authority; ARE) without any workflow. Billed once, only when
+      # the identity is verified. The response carries next_action.type=redirect with the URL to send the user's
+      # browser to; the user returns to return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/uae-pass/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the UAE PASS identity. Defaults to ARE, the only country
+      #   it serves. * `ARE` - ARE
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_uae_pass(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/uae-pass/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+
+      # Start Vipps verification
+      #
+      # Start a Vipps sign-in (Vipps MobilePay / BankID NO; NOR) without any workflow. Billed once, only when the
+      # identity is verified. The response carries next_action.type=redirect with the URL to send the user's browser
+      # to; the user returns to return_url with request_id and result appended. Read the outcome with GET
+      # /v3/id-verification/wallets/verifications/{request_id}/ or from the webhook, never from the URL. Sandbox
+      # applications get a deterministic simulation (simulated: true) that never contacts the provider.
+      #
+      # +POST /v3/id-verification/wallets/vipps/+
+      #
+      # @param return_url [String] https URL the user's browser returns to after the wallet, with request_id and
+      #   result appended. Its host must be registered in the application's allowed_return_hosts (or be its white-label
+      #   domain). Never trust result on its own: read the outcome with GET .../verifications/{request_id}/ or the
+      #   webhook.
+      # @param vendor_data [String, nil] Your own reference for this verification (e.g. your user id). Returned in
+      #   results and webhooks.
+      # @param metadata [Hash, nil] Optional JSON object stored with the verification and returned in results and
+      #   webhooks.
+      # @param sandbox_scenario [String] Sandbox applications only: the simulated outcome - 'wallet_cancelled',
+      #   'wallet_timeout' or 'wallet_provider_error'; any other scenario (or none) verifies. Rejected on live
+      #   applications. The full catalog is available at GET /v1/sandbox/scenarios/.
+      # @param country [String] ISO 3166-1 alpha-3 country of the Vipps identity. Defaults to NOR, the only country it
+      #   serves. * `NOR` - NOR
+      # @param device [String] same_device when the user signs in on the device showing your page, cross_device when
+      #   they use another one (e.g. BankID's QR code). * `same_device` - same_device * `cross_device` - cross_device
+      # @param idempotency_key [String] sent as the Idempotency-Key header
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::DigitalIdWalletApiWalletVerificationResponse]
+      def start_vipps(
+        return_url:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        sandbox_scenario: OMIT,
+        country: OMIT,
+        device: OMIT,
+        idempotency_key: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/id-verification/wallets/vipps/",
+          body: {
+            "return_url" => return_url,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "sandbox_scenario" => sandbox_scenario,
+            "country" => country,
+            "device" => device
+          },
+          headers: { "Idempotency-Key" => idempotency_key },
+          response: Types::DigitalIdWalletApiWalletVerificationResponse,
+          request_options: request_options
+        )
+      end
+    end
+  end
+end