didit-sdk 1.0.0

data/lib/didit/resources/kyb.rb

@@ -0,0 +1,256 @@
+# Code generated by codegen from openapi/*.json. DO NOT EDIT.
+# frozen_string_literal: true
+
+module Didit
+  module Resources
+    # The +kyb+ resource.
+    class Kyb < Didit::Resource
+      # KYB registry company with shareholders (standalone)
+      #
+      # Retrieve the Lite profile **plus the direct shareholders** (natural persons and corporate entities, with their
+      # ownership bands) of one candidate returned by `POST /v3/kyb/search/`.
+      #
+      # **Pairing with search.** Pass the candidate's `kyb_response_id` exactly as returned by a search of the same
+      # application. The search runs on the Lite registry chain; when the country's ownership data lives at another
+      # registry Didit re-finds the company there by registration number, at no extra cost.
+      #
+      # **Billing.** Billed at the country's Shareholders price - see [KYB registry
+      # pricing](/getting-started/kyb-registry-pricing). When the registry holds no shareholder record for the company
+      # (or the country offers no ownership data at all) the Lite profile is delivered and billed instead: read
+      # `registry_tier_delivered` and `registry_ownership_status`. The balance is checked against the Shareholders
+      # price before any registry call (`403` when short).
+      #
+      # **Availability.** v3 only. Every call creates a business session (its id is the `request_id`).
+      #
+      # **Pending reports.** When a report is still being prepared, or the ownership section has not been retrieved
+      # from the registry yet, the endpoint returns 202 Accepted, kyb_registry.fetch_status=pending,
+      # kyb_registry.registry_ownership_status=pending, and registry_tier_delivered=null. Keep request_id and retrieve
+      # GET /v3/session/{request_id}/decision/ until registry_checks[0].company.fetch_status is resolved. Didit
+      # completes the report automatically and charges the delivered tier once it is ready. Do not repeat the purchase
+      # while it is pending; every new POST creates a separate request.
+      #
+      # +POST /v3/kyb/shareholders/+
+      #
+      # @param kyb_response_id [String] Candidate handle from `POST /v3/kyb/search/`
+      #   (`kyb_registry.companies[].kyb_response_id`). Ephemeral - use it shortly after the search that produced it.
+      # @param vendor_data [String] Your identifier for this company; echoed back and stored with the business
+      #   session.
+      # @param metadata [Hash, nil] Free-form JSON stored with the business session and echoed back.
+      # @param save_api_request [Boolean] Must be `true` (the default). KYB registry selects are always persisted so
+      #   billing and retrieval can be tracked; `false` returns `400`.
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::KybListShareholdersResponse, Didit::Types::KybListShareholdersResponse202]
+      def list_shareholders(
+        kyb_response_id:,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        save_api_request: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/kyb/shareholders/",
+          body: {
+            "kyb_response_id" => kyb_response_id,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "save_api_request" => save_api_request
+          },
+          response: { 200 => Types::KybListShareholdersResponse, 202 => Types::KybListShareholdersResponse202 },
+          request_options: request_options
+        )
+      end
+
+      # KYB registry company with ultimate beneficial owners (standalone)
+      #
+      # Retrieve the Lite profile, the direct shareholders **and the ultimate beneficial owners** resolved through the
+      # ownership chain (`registry_data.ubo_resolution` carries the corporate parent chain) of one candidate returned
+      # by `POST /v3/kyb/search/`.
+      #
+      # **Pairing with search.** Pass the candidate's `kyb_response_id` exactly as returned by a search of the same
+      # application. The search runs on the Lite registry chain; when the country's ownership data lives at another
+      # registry Didit re-finds the company there by registration number, at no extra cost.
+      #
+      # **Billing.** Billed at the country's UBO price - see [KYB registry
+      # pricing](/getting-started/kyb-registry-pricing). The tier delivered is the highest the country and the
+      # registry can serve: Shareholders when the resolved report names no natural person as a beneficial owner, Lite
+      # when there is no ownership record at all; `registry_tier_delivered` names what was billed. The balance is
+      # checked against the UBO price before any registry call (`403` when short).
+      #
+      # **Availability.** v3 only. Every call creates a business session (its id is the `request_id`).
+      #
+      # **Pending reports.** When a report is still being prepared, or the ownership section has not been retrieved
+      # from the registry yet, the endpoint returns 202 Accepted, kyb_registry.fetch_status=pending,
+      # kyb_registry.registry_ownership_status=pending, and registry_tier_delivered=null. Keep request_id and retrieve
+      # GET /v3/session/{request_id}/decision/ until registry_checks[0].company.fetch_status is resolved. Didit
+      # completes the report automatically and charges the delivered tier once it is ready. Do not repeat the purchase
+      # while it is pending; every new POST creates a separate request.
+      #
+      # +POST /v3/kyb/ubo/+
+      #
+      # @param kyb_response_id [String] Candidate handle from `POST /v3/kyb/search/`
+      #   (`kyb_registry.companies[].kyb_response_id`). Ephemeral - use it shortly after the search that produced it.
+      # @param vendor_data [String] Your identifier for this company; echoed back and stored with the business
+      #   session.
+      # @param metadata [Hash, nil] Free-form JSON stored with the business session and echoed back.
+      # @param save_api_request [Boolean] Must be `true` (the default). KYB registry selects are always persisted so
+      #   billing and retrieval can be tracked; `false` returns `400`.
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::KybListUbosResponse, Didit::Types::KybListUbosResponse202]
+      def list_ubos(kyb_response_id:, vendor_data: OMIT, metadata: OMIT, save_api_request: OMIT, request_options: nil)
+        @client.request(
+          :post,
+          "/v3/kyb/ubo/",
+          body: {
+            "kyb_response_id" => kyb_response_id,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "save_api_request" => save_api_request
+          },
+          response: { 200 => Types::KybListUbosResponse, 202 => Types::KybListUbosResponse202 },
+          request_options: request_options
+        )
+      end
+
+      # KYB registry company search (standalone)
+      #
+      # Search official company registries for candidate companies by name and/or registration number. This is step 1
+      # of the two-step registry flow: **search** returns lightweight candidates, then `POST /v3/kyb/select/`
+      # retrieves the full profile of one candidate.
+      #
+      # **Search billing.** Successful searches using a paid company-data source cost USD 0.50 per request, regardless
+      # of candidate count. Empty results, failures and results served only by other sources are not charged. The
+      # applicable price is reserved before searching; insufficient balance returns 403 with code
+      # `insufficient_credits`. Contract rates apply where agreed, and an unconfigured contract search rate returns
+      # 403. Sandbox searches are free. Repeating a successful search can incur another charge; callback delivery does
+      # not add a charge. Profile retrieval is billed separately. This search fee also applies to v2. Candidates
+      # always come back with `fetch_status: "pending"`: the full company data is only fetched (and billed) on select.
+      #
+      # **`kyb_response_id` is ephemeral.** It is a per-search handle, not a stable company id. Select promptly after
+      # searching and re-search to get a fresh handle instead of storing it.
+      #
+      # **`tier` picks the provider chain.** `tier` names the registry tier the search runs on: `basic` (the default,
+      # the Lite chain), `shareholders` or `ubo`. The search uses the provider chain that serves that tier, and it is
+      # not always the same chain the Lite search reads, so an empty Lite search is not proof that the registry does
+      # not hold the company - search again at the tier you need. A country that does not offer the tier you name is
+      # searched at the highest tier it offers up to that one. Retrieve the candidate from the endpoint that sells
+      # that tier: `POST /v3/kyb/select/` (Lite), `POST /v3/kyb/shareholders/` or `POST /v3/kyb/ubo/`.
+      #
+      # **Authentication.** `POST /v3/kyb/search/` (and `/v2/`) takes your application's API key in the `x-api-key`
+      # header. The hosted `POST /v1/kyb/search/` is the session-authenticated route a hosted verification flow calls:
+      # it answers `403` to an API key and takes no `tier` - the workflow's KYB registry configuration picks the
+      # chain.
+      #
+      # **Two modes.**
+      # - *Synchronous (default):* the API polls the registry until the search resolves and returns the final
+      #   candidate list (`search_resolved: true`).
+      # - *Asynchronous:* pass `webhook_url` and the API returns immediately - usually with `search_status: "pending"`
+      #   and an empty candidate list - then POSTs a `kyb.registry_search.resolved` callback to your URL when the
+      #   registry finishes. The callback body is `{"event_id", "event_type": "kyb.registry_search.resolved",
+      #   "request_id", "vendor_data", "metadata", "search_status", "search_resolved", "kyb_registry", "timestamp",
+      #   "created_at"}` - note `timestamp` and `created_at` in the callback are epoch integers, unlike this
+      #   endpoint's ISO `created_at` - and is sent **unsigned** (header `X-Didit-Unsigned-Callback: true`, no
+      #   `X-Signature`).
+      #
+      # **Country codes.** ISO 3166-1 alpha-2 (`GB`, `DE`), plus `XX-YY` subdivision codes where registries are
+      # regional - e.g. `US-CA` for California.
+      #
+      # **Sandbox.** Keys from sandbox applications return one static candidate without contacting any registry.
+      #
+      # +POST /v3/kyb/search/+
+      #
+      # @param country_code [String] ISO 3166-1 alpha-2 code of the country whose company registry to search. For
+      #   example, `GB`. Where company registries operate at state or province level, append the ISO 3166-2 subdivision
+      #   code as `XX-YY`: `US-CA` searches the California registry. United States searches always require the
+      #   subdivision - a bare `US` is rejected. Case-insensitive; normalized to upper case.
+      # @param name [String] Company name to search for. Either `name` or `registration_number` is required.
+      # @param registration_number [String] Registry registration number to search for. Either `name` or
+      #   `registration_number` is required.
+      # @param tier [String] Registry tier whose provider chain this search runs on. `basic` (default) searches the
+      #   country's Lite chain; `shareholders` and `ubo` search that tier's ownership chain, which can be a different
+      #   source, so an empty Lite search does not prove the registry lacks the company. A country that does not offer
+      #   the named tier is searched at the highest tier it offers up to that one. Retrieve the candidate...
+      # @param search_type [String] Name-matching strategy applied by the registry search. `contains` is the only
+      #   accepted value: no registry source behind the search offers a prefix or fuzzy mode, so `start_with` and
+      #   `fuzzy` are rejected with `400` (`not a valid choice`).
+      # @param vendor_data [String] Your identifier for this lookup; echoed back and included in the webhook callback.
+      # @param metadata [Hash, nil] Free-form JSON; echoed back and included in the webhook callback.
+      # @param webhook_url [String] Switches the search to asynchronous mode: the API returns immediately and POSTs an
+      #   unsigned `kyb.registry_search.resolved` callback to this URL when the candidate list is ready.
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::KybSearchResponse]
+      def search(
+        country_code:,
+        name: OMIT,
+        registration_number: OMIT,
+        tier: OMIT,
+        search_type: OMIT,
+        vendor_data: OMIT,
+        metadata: OMIT,
+        webhook_url: OMIT,
+        request_options: nil
+      )
+        @client.request(
+          :post,
+          "/v3/kyb/search/",
+          body: {
+            "country_code" => country_code,
+            "name" => name,
+            "registration_number" => registration_number,
+            "tier" => tier,
+            "search_type" => search_type,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "webhook_url" => webhook_url
+          },
+          response: Types::KybSearchResponse,
+          request_options: request_options
+        )
+      end
+
+      # KYB registry company select - Lite tier (standalone)
+      #
+      # Retrieve the **Lite** registry profile of one candidate returned by `POST /v3/kyb/search/` - company details,
+      # registered address, identifiers, status, activity and the officers, plus the raw registry payload.
+      # Shareholders and ultimate beneficial owners are sold by `POST /v3/kyb/shareholders/` and `POST /v3/kyb/ubo/`.
+      #
+      # **Pairing with search.** Pass the candidate's `kyb_response_id` exactly as returned by a search of the same
+      # application. The handle is ephemeral and scoped to that search - select promptly, and re-search for a fresh
+      # handle rather than storing it.
+      #
+      # **Billing.** Each select is billed at the country's Lite price (any search fee is separate); see [KYB registry
+      # pricing](/getting-started/kyb-registry-pricing). The balance is checked before any registry call (`403` when
+      # short) and the charge is recorded against the created business session.
+      #
+      # **Persistence is mandatory.** Every select creates a business session (its id is the `request_id`) so billing
+      # and retrieval can be tracked; it appears in the console. `save_api_request` is accepted for symmetry but must
+      # be `true` (the default) - sending `false` returns `400`.
+      #
+      # +POST /v3/kyb/select/+
+      #
+      # @param kyb_response_id [String] Candidate handle from `POST /v3/kyb/search/`
+      #   (`kyb_registry.companies[].kyb_response_id`). Ephemeral - use it shortly after the search that produced it.
+      # @param vendor_data [String] Your identifier for this company; echoed back and stored with the business
+      #   session.
+      # @param metadata [Hash, nil] Free-form JSON stored with the business session and echoed back.
+      # @param save_api_request [Boolean] Must be `true` (the default). KYB registry selects are always persisted so
+      #   billing and retrieval can be tracked; `false` returns `400`.
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::KybSelectResponse]
+      def select(kyb_response_id:, vendor_data: OMIT, metadata: OMIT, save_api_request: OMIT, request_options: nil)
+        @client.request(
+          :post,
+          "/v3/kyb/select/",
+          body: {
+            "kyb_response_id" => kyb_response_id,
+            "vendor_data" => vendor_data,
+            "metadata" => metadata,
+            "save_api_request" => save_api_request
+          },
+          response: Types::KybSelectResponse,
+          request_options: request_options
+        )
+      end
+    end
+  end
+end

data/lib/didit/resources/lists.rb

@@ -0,0 +1,332 @@
+# Code generated by codegen from openapi/*.json. DO NOT EDIT.
+# frozen_string_literal: true
+
+module Didit
+  module Resources
+    # The +lists+ resource.
+    class Lists < Didit::Resource
+      # @return [Didit::Resources::Lists::Entries]
+      def entries
+        @entries ||= Entries.new(@client)
+      end
+
+      # Create a list
+      #
+      # Creates an allowlist or a custom list in the application the API key belongs to. Blocklists cannot be created:
+      # Didit provisions one system blocklist per entry type, and you add to it with [Create a list
+      # entry](https://docs.didit.me/management-api/lists/create-entry). `entry_type` cannot change after creation and
+      # decides how entry values are validated and matched. Allowlist entries mark matching items as trusted (for
+      # example, a face allowlist skips the duplicated-face action) and never override a blocklist match; reference
+      # any list from a workflow or transaction rule condition with `value_type: "list"`. A scoped API key needs
+      # `workflows: write`.
+      #
+      # +POST /v3/lists/+
+      #
+      # @param name [String] List name. Must differ from the name of every other list of the application, system lists
+      #   included.
+      # @param list_type [String] `allowlist` or `custom`. `blocklist` is refused with `400`.
+      # @param entry_type [String] What the list holds: `face`, `document` (document number), `phone`, `email`,
+      #   `ip_address` (IP address or CIDR range), `device_fingerprint`, `wallet_address`, `bank_account`, `country`
+      #   (ISO 3166-1 alpha-3), `user` or `business` (your `vendor_data`), or `key` (any string). It decides how entry
+      #   values are validated and matched. Cannot be changed later.
+      # @param description [String] Optional free-text description.
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::ComplianceList]
+      def create(name:, list_type:, entry_type:, description: OMIT, request_options: nil)
+        @client.request(
+          :post,
+          "/v3/lists/",
+          body: {
+            "name" => name,
+            "list_type" => list_type,
+            "entry_type" => entry_type,
+            "description" => description
+          },
+          response: Types::ComplianceList,
+          request_options: request_options
+        )
+      end
+
+      # Delete a list
+      #
+      # Deletes an allowlist or custom list together with its entries. Deletion is irreversible: the list and its
+      # entries no longer appear in any read, and workflow and transaction rule conditions that reference the list
+      # evaluate it as an empty list from then on. Sessions and transactions already evaluated keep their results, and
+      # the name can be reused for a new list. System lists cannot be deleted and return `400`; to empty one, [delete
+      # its entries](https://docs.didit.me/management-api/lists/delete-entry). A scoped API key needs `workflows:
+      # write`.
+      #
+      # +DELETE /v3/lists/{list_uuid}/+
+      #
+      # @param list_uuid [String] UUID of the list, as returned by List lists or Create a list.
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [nil]
+      def delete(list_uuid, request_options: nil)
+        @client.request(
+          :delete,
+          "/v3/lists/{list_uuid}/",
+          path_params: { "list_uuid" => list_uuid },
+          request_options: request_options
+        )
+      end
+
+      # List lists
+      #
+      # Returns the application's lists, newest first: the system lists Didit provisions (one blocklist per entry
+      # type, the **High Risk Countries** custom list, and any system allowlist) and the allowlists and custom lists
+      # you created. Filter with `list_type` and `entry_type`; deleted lists never appear. Results are paginated with
+      # `limit` and `offset`. A scoped API key needs `workflows: read`. See
+      # [Lists](https://docs.didit.me/management-api/lists/overview) for what each list type does.
+      #
+      # +GET /v3/lists/+
+      #
+      # @param list_type [String] Only lists of this type.
+      # @param entry_type [String] Only lists of this entry type.
+      # @param ordering [String] Sort order: `-created_at` (newest first, the default) or `created_at` (oldest first).
+      # @param limit [Integer] Page size. Defaults to 50. A value above 1000000 returns `400`; zero, a negative or a
+      #   non-numeric value falls back to 50.
+      # @param offset [Integer] Zero-based index of the first item to return. Prefer following `next`. A value above
+      #   1000000 returns `400`; a negative or non-numeric value falls back to 0.
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Page<Didit::Types::ComplianceList>]
+      def list(list_type: OMIT, entry_type: OMIT, ordering: OMIT, limit: OMIT, offset: OMIT, request_options: nil)
+        @client.request(
+          :get,
+          "/v3/lists/",
+          query: {
+            "list_type" => list_type,
+            "entry_type" => entry_type,
+            "ordering" => ordering,
+            "limit" => limit,
+            "offset" => offset
+          },
+          page: Types::ComplianceList,
+          request_options: request_options
+        )
+      end
+
+      # Get a list
+      #
+      # Returns one list of the application with its entry count and when its newest entry was added. A list of
+      # another application, or one that was deleted, returns `404`. This returns the list only: read its values with
+      # [List list entries](https://docs.didit.me/management-api/lists/list-entries). A scoped API key needs
+      # `workflows: read`.
+      #
+      # +GET /v3/lists/{list_uuid}/+
+      #
+      # @param list_uuid [String] UUID of the list, as returned by List lists or Create a list.
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::ComplianceList]
+      def retrieve(list_uuid, request_options: nil)
+        @client.request(
+          :get,
+          "/v3/lists/{list_uuid}/",
+          path_params: { "list_uuid" => list_uuid },
+          response: Types::ComplianceList,
+          request_options: request_options
+        )
+      end
+
+      # Update a list
+      #
+      # Renames a list or changes its description. Only `name` and `description` are read; any other field is ignored,
+      # so `list_type` and `entry_type` keep the values they were created with. System lists cannot be modified and
+      # return `400`. The response contains only `name` and `description`: call [Get a
+      # list](https://docs.didit.me/management-api/lists/get) for the full list. A scoped API key needs `workflows:
+      # write`.
+      #
+      # +PATCH /v3/lists/{list_uuid}/+
+      #
+      # @param list_uuid [String] UUID of the list, as returned by List lists or Create a list.
+      # @param name [String] New name. Must differ from the name of every other list of the application.
+      # @param description [String] New description. Send an empty string to clear it.
+      # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+      # @return [Didit::Types::ListsUpdateResponse]
+      def update(list_uuid, name: OMIT, description: OMIT, request_options: nil)
+        @client.request(
+          :patch,
+          "/v3/lists/{list_uuid}/",
+          path_params: { "list_uuid" => list_uuid },
+          body: {
+            "name" => name,
+            "description" => description
+          },
+          response: Types::ListsUpdateResponse,
+          request_options: request_options
+        )
+      end
+
+      # The +lists.entries+ resource.
+      class Entries < Didit::Resource
+        # Create a list entry
+        #
+        # Adds one entry to a list, in one of three ways: by `value`; from a verification session with
+        # `reference_session_id`, where Didit reads the value from the session's most recent record of the list's
+        # entry type and links the entry to it; or by `value` with a `reference_object_uuid` and
+        # `metadata.reference_type` pointing back to a transaction, user or business. On the system face, document,
+        # phone and email blocklists, the record read from the session is also flagged as blocklisted, so new matching
+        # sessions are declined; on the system user and business blocklists, matching users or businesses are set to
+        # `BLOCKED`. Sessions and transactions that already finished are not changed. A scoped API key needs
+        # `workflows: write`. See [Create a list entry](https://docs.didit.me/management-api/lists/create-entry) for
+        # each mode.
+        #
+        # +POST /v3/lists/{list_uuid}/entries/+
+        #
+        # @param list_uuid [String] UUID of the list to add to. For a face you only have as an image, use Upload a
+        #   face to a list instead.
+        # @param value [String] The value to list, validated against the list's `entry_type`: `email` a valid email
+        #   address; `phone` a valid international number, stored in E.164; `ip_address` an IP address or CIDR range
+        #   (for example `10.0.0.0/8`); `device_fingerprint` at least 8 characters among letters, digits, `-`, `_`, `:`
+        #   and `.` (a blocklist refuses a fingerprint that several distinct devices have reported); `country` an...
+        # @param reference_session_id [String] A person or business verification session of your application to take
+        #   the value from. Didit reads the session's most recent record of the list's entry type (`face`, `document`,
+        #   `phone`, `email`, `ip_address` or `device_fingerprint`), links the entry to the session and to that record,
+        #   and fills `display_label` and `metadata` for documents. For a `device_fingerprint` blocklist, a session that
+        #   only...
+        # @param reference_object_uuid [String] UUID of the record the entry stands for when it does not come from a
+        #   session: a transaction UUID, or the `didit_internal_id` of a user or business. Pair it with
+        #   `metadata.reference_type`. Replaced by the session's record when `reference_session_id` provides one.
+        # @param face_image_source [String] Face lists with `reference_session_id`: which of the session's images the
+        #   face is taken from. `liveness` (default) is the liveness selfie. `front_image_camera_front` and
+        #   `back_image_camera_front` are the selfies the front camera took while the user photographed the front or
+        #   back of their document: accepted only on the system face blocklist, with `reference_session_id` and an empty
+        #   `value`. Each s...
+        # @param reference_node_id [String, nil] With a document-capture `face_image_source`: the ID verification node
+        #   whose selfie to use, for workflows with more than one. Defaults to the most recent ID verification that has
+        #   that image. Refused with `liveness`.
+        # @param display_label [String] Human-readable label. When empty, Didit derives one from the session where it
+        #   can (for example the holder's name and document number).
+        # @param comment [String] Free-text note, such as the reason for listing.
+        # @param metadata [Hash] Free-form JSON stored with the entry and returned as stored. Use `reference_type` and
+        #   `reference_id` so the console links back to the source. `reference_image_url` and `front_image_url` are set
+        #   by Didit only and are dropped if you send them. For an entry read from a session, Didit's keys are merged
+        #   with yours.
+        # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+        # @return [Didit::Types::ComplianceListEntry]
+        def create(
+          list_uuid,
+          value: OMIT,
+          reference_session_id: OMIT,
+          reference_object_uuid: OMIT,
+          face_image_source: OMIT,
+          reference_node_id: OMIT,
+          display_label: OMIT,
+          comment: OMIT,
+          metadata: OMIT,
+          request_options: nil
+        )
+          @client.request(
+            :post,
+            "/v3/lists/{list_uuid}/entries/",
+            path_params: { "list_uuid" => list_uuid },
+            body: {
+              "value" => value,
+              "reference_session_id" => reference_session_id,
+              "reference_object_uuid" => reference_object_uuid,
+              "face_image_source" => face_image_source,
+              "reference_node_id" => reference_node_id,
+              "display_label" => display_label,
+              "comment" => comment,
+              "metadata" => metadata
+            },
+            response: Types::ComplianceListEntry,
+            request_options: request_options
+          )
+        end
+
+        # Delete a list entry
+        #
+        # Deletes one entry from a list, system lists included. The entry stops matching at once, and deletion is
+        # irreversible: to list the value again, create a new entry. On a system face, document, phone or email
+        # blocklist, the record the entry stands for is no longer flagged as blocklisted; on the system user or
+        # business blocklist, users or businesses of the application whose `vendor_data` equals the entry's value (or
+        # whose `didit_internal_id` equals its `reference_object_uuid`) and that are `BLOCKED` return to `ACTIVE`.
+        # Sessions and transactions that already finished keep their status. A scoped API key needs `workflows:
+        # write`.
+        #
+        # +DELETE /v3/lists/{list_uuid}/entries/{entry_uuid}/+
+        #
+        # @param list_uuid [String] UUID of the list that holds the entry.
+        # @param entry_uuid [String] UUID of the entry, as returned by List list entries or Create a list entry.
+        # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+        # @return [nil]
+        def delete(list_uuid, entry_uuid, request_options: nil)
+          @client.request(
+            :delete,
+            "/v3/lists/{list_uuid}/entries/{entry_uuid}/",
+            path_params: { "list_uuid" => list_uuid, "entry_uuid" => entry_uuid },
+            request_options: request_options
+          )
+        end
+
+        # List list entries
+        #
+        # Returns the current entries of one list, newest first. `search` matches part of an entry's `value` or
+        # `display_label` without regard to case, and `reference_session_id` narrows the results to the entries taken
+        # from one person verification session. Image URLs in `metadata` are short-lived signed URLs issued again on
+        # every call; a scoped API key without `media: read` receives `null` in their place. A scoped API key needs
+        # `workflows: read`.
+        #
+        # +GET /v3/lists/{list_uuid}/entries/+
+        #
+        # @param list_uuid [String] UUID of the list, as returned by List lists or Create a list.
+        # @param search [String] Case-insensitive text that the entry's `value` or `display_label` must contain.
+        # @param reference_session_id [String] Only the entries taken from this person verification session, for
+        #   example to see which of its faces are already listed.
+        # @param limit [Integer] Page size. Defaults to 50. A value above 1000000 returns `400`; zero, a negative or a
+        #   non-numeric value falls back to 50.
+        # @param offset [Integer] Zero-based index of the first item to return. Prefer following `next`. A value above
+        #   1000000 returns `400`; a negative or non-numeric value falls back to 0.
+        # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+        # @return [Didit::Page<Didit::Types::ComplianceListEntry>]
+        def list(list_uuid, search: OMIT, reference_session_id: OMIT, limit: OMIT, offset: OMIT, request_options: nil)
+          @client.request(
+            :get,
+            "/v3/lists/{list_uuid}/entries/",
+            path_params: { "list_uuid" => list_uuid },
+            query: {
+              "search" => search,
+              "reference_session_id" => reference_session_id,
+              "limit" => limit,
+              "offset" => offset
+            },
+            page: Types::ComplianceListEntry,
+            request_options: request_options
+          )
+        end
+
+        # Upload a face to a list
+        #
+        # Adds a face to a face blocklist or face allowlist from a base64-encoded JPEG or PNG image, for when you have
+        # no verification session to reference. Didit detects the faces in the image, uses the largest one, and
+        # creates an entry whose `value` and `reference_object_uuid` are the UUID of the new face. A blocklisted face
+        # declines new sessions whose face matches; an allowlisted face skips the duplicated-face action and never
+        # overrides a blocklist match. In a sandbox application the image is not analyzed and the entry matches
+        # nothing. A scoped API key needs `workflows: write`. To list a face from an existing session, use [Create a
+        # list entry](https://docs.didit.me/management-api/lists/create-entry) with `reference_session_id` instead.
+        #
+        # +POST /v3/lists/{list_uuid}/entries/face-upload/+
+        #
+        # @param list_uuid [String] UUID of a list with `entry_type: face` and `list_type: blocklist` or `allowlist`.
+        # @param image [String] Base64-encoded JPEG or PNG, at most 2 MB once decoded, showing a clearly visible face.
+        #   Send the bare base64 string, without a `data:image/...;base64,` prefix.
+        # @param comment [String] Optional free-text note, such as the reason for listing.
+        # @param request_options [Hash, nil] :timeout, :max_retries, :extra_headers, :extra_query, :extra_body
+        # @return [Didit::Types::ComplianceListEntry]
+        def upload_face(list_uuid, image:, comment: OMIT, request_options: nil)
+          @client.request(
+            :post,
+            "/v3/lists/{list_uuid}/entries/face-upload/",
+            path_params: { "list_uuid" => list_uuid },
+            body: {
+              "image" => image,
+              "comment" => comment
+            },
+            response: Types::ComplianceListEntry,
+            request_options: request_options
+          )
+        end
+      end
+    end
+  end
+end