from didit import Didit

# Reads DIDIT_API_KEY.
client = Didit()

result = client.fraud_checks.plan(
    client_reference="review-attempt-001",
    subject={
        "identifiers": [{
            "type": "email",
            "value": "applicant@example.com",
        }],
        "attributes": {
            "first_name": "Alex",
            "last_name": "Example",
        },
    },
    checks={
        "include": ["networks_same_org", "networks_cross_org", "email_risk"],
    },
)
print(result)

import Didit from "@didit-protocol/sdk-node";

// Reads DIDIT_API_KEY.
const didit = new Didit();

const result = await didit.fraudChecks.plan({
  client_reference: "review-attempt-001",
  subject: {
    identifiers: [{
      type: "email",
      value: "applicant@example.com",
    }],
    attributes: {
      first_name: "Alex",
      last_name: "Example",
    },
  },
  checks: {
    include: ["networks_same_org", "networks_cross_org", "email_risk"],
  },
});
console.log(result);

ctx := context.Background()
// Reads DIDIT_API_KEY.
client := didit.NewClient()

result, err := client.FraudChecks.Plan(ctx, didit.FraudCheckRequestRequest{
	ClientReference: didit.String("review-attempt-001"),
	Subject: didit.FraudCheckSubjectRequest{
		Identifiers: []didit.FraudCheckIdentifierRequest{{
			Type:  didit.FraudTypeEnum("email"),
			Value: "applicant@example.com",
		}},
		Attributes: didit.Some(didit.FraudCheckAttributesRequest{
			FirstName: didit.String("Alex"),
			LastName:  didit.String("Example"),
		}),
	},
	Checks: didit.Some(didit.FraudCheckModuleSelectionRequest{
		Include: didit.Some([]didit.FraudExcludeEnum{didit.FraudExcludeEnum("networks_same_org"), didit.FraudExcludeEnum("networks_cross_org"), didit.FraudExcludeEnum("email_risk")}),
	}),
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("%+v\n", result)

import java.util.List;
import me.didit.Didit;
import me.didit.types.FraudCheckAttributesRequest;
import me.didit.types.FraudCheckIdentifierRequest;
import me.didit.types.FraudCheckModuleSelectionRequest;
import me.didit.types.FraudCheckRequestRequest;
import me.didit.types.FraudCheckSubjectRequest;
import me.didit.types.FraudExcludeEnum;
import me.didit.types.FraudTypeEnum;

// Reads DIDIT_API_KEY.
Didit client = new Didit();

var result = client.fraudChecks().plan(FraudCheckRequestRequest.builder()
        .clientReference("review-attempt-001")
        .subject(FraudCheckSubjectRequest.builder()
                .identifiers(List.of(FraudCheckIdentifierRequest.builder()
                        .type(FraudTypeEnum.of("email"))
                        .value("applicant@example.com")
                        .build()))
                .attributes(FraudCheckAttributesRequest.builder()
                        .firstName("Alex")
                        .lastName("Example")
                        .build())
                .build())
        .checks(FraudCheckModuleSelectionRequest.builder()
                .include(List.of(FraudExcludeEnum.of("networks_same_org"), FraudExcludeEnum.of("networks_cross_org"), FraudExcludeEnum.of("email_risk")))
                .build())
        .build());
System.out.println(result);

<?php

require 'vendor/autoload.php';

use Didit\DiditClient;

// Reads DIDIT_API_KEY.
$didit = new DiditClient();

$result = $didit->fraudChecks->plan([
    'client_reference' => 'review-attempt-001',
    'subject' => [
        'identifiers' => [[
            'type' => 'email',
            'value' => 'applicant@example.com',
        ]],
        'attributes' => [
            'first_name' => 'Alex',
            'last_name' => 'Example',
        ],
    ],
    'checks' => [
        'include' => ['networks_same_org', 'networks_cross_org', 'email_risk'],
    ],
]);
print_r($result->toArray());

require "didit"

# Reads DIDIT_API_KEY.
didit = Didit::Client.new

result = didit.fraud_checks.plan(
  client_reference: "review-attempt-001",
  subject: {
    identifiers: [{
      type: "email",
      value: "applicant@example.com",
    }],
    attributes: {
      first_name: "Alex",
      last_name: "Example",
    },
  },
  checks: {
    include: ["networks_same_org", "networks_cross_org", "email_risk"],
  }
)
puts result.to_h

using System;
using System.Text.Json;
using Didit;

// Reads DIDIT_API_KEY.
using var client = new DiditClient();

var result = await client.FraudChecks.PlanAsync(new FraudCheckRequestRequest
{
    ClientReference = "review-attempt-001",
    Subject = new()
    {
        Identifiers = new FraudCheckIdentifierRequest[]
        {
            new()
            {
                Type = "email",
                Value = "applicant@example.com",
            },
        },
        Attributes = new FraudCheckAttributesRequest
        {
            FirstName = "Alex",
            LastName = "Example",
        },
    },
    Checks = new FraudCheckModuleSelectionRequest
    {
        Include = new FraudExcludeEnum[] { "networks_same_org", "networks_cross_org", "email_risk" },
    },
});
Console.WriteLine(JsonSerializer.Serialize(result));

curl --request POST \
  --url https://verification.didit.me/v3/fraud/checks/plan/ \
  --header 'Content-Type: application/x-www-form-urlencoded' \
  --header 'x-api-key: <api-key>' \
  --data 'subject={
  "identifiers": [
    {
      "value": "<string>",
      "country": "<string>",
      "issuer": "<string>"
    }
  ],
  "selfie": "<string>",
  "attributes": {
    "first_name": "<string>",
    "last_name": "<string>",
    "full_name": "<string>",
    "date_of_birth": "2023-12-25",
    "nationality": "<string>",
    "gender": "<string>",
    "address": "<string>",
    "city": "<string>",
    "state": "<string>",
    "postal_code": "<string>"
  }
}' \
  --data 'client_reference=<string>' \
  --data profile=standard \
  --data 'profile_version=<string>' \
  --data 'context={
  "ip_address": "<string>",
  "user_agent": "<string>",
  "country": "<string>",
  "purpose": "<string>",
  "consent_obtained": true
}' \
  --data 'checks={
  "include": [],
  "exclude": []
}' \
  --data 'vendor_data=<string>' \
  --data 'metadata=<unknown>'

{
  "profile_id": "<string>",
  "profile_version": "<string>",
  "modules": [
    {
      "module": "normalization",
      "available": true,
      "availability_reason": "<string>",
      "will_run": true,
      "selection_reason": "<string>",
      "estimated_price": "<string>"
    }
  ],
  "estimated_price": "<string>",
  "currency": "<string>",
  "is_sandbox": true,
  "can_afford": true
}

{
  "detail": "Bad Request - Invalid request data"
}