curl -X POST 'https://verification.didit.me/v3/transactions/rules/' \
  -H 'x-api-key: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"title": "Structuring - inbound (custom)", "description": "20+ inbound EUR transfers, all under 10,000 EUR, 30 days", "category": "finance", "mode": "TEST", "evaluation_mode": "ALL", "scope": {"transaction_types": ["finance"], "directions": ["INBOUND"]}, "conditions": [{"field": "currency", "operator": "eq", "value": "EUR"}, {"field": "amount", "operator": "lt", "value": 10000}], "aggregation": [{"metric": "count", "operator": "gte", "value": 20, "window": "30d", "filters": {"direction": "INBOUND", "transaction_type": "finance", "subject_vendor_data": "__current__", "currency": "EUR"}}, {"metric": "max", "field": "amount", "operator": "lt", "value": 10000, "window": "30d", "filters": {"direction": "INBOUND", "transaction_type": "finance", "subject_vendor_data": "__current__", "currency": "EUR"}}], "actions": [{"type": "add_score", "value": 35}]}'

from didit import Didit

# Reads DIDIT_API_KEY.
client = Didit()

result = client.transactions.rules.create(
    title="Structuring - inbound (custom)",
    description="20+ inbound EUR transfers, all under 10,000 EUR, 30 days",
    category="finance",
    mode="TEST",
    evaluation_mode="ALL",
    scope={
        "transaction_types": ["finance"],
        "directions": ["INBOUND"],
    },
    conditions=[{
        "field": "currency",
        "operator": "eq",
        "value": "EUR",
    }, {
        "field": "amount",
        "operator": "lt",
        "value": 10000,
    }],
    aggregation=[{
        "metric": "count",
        "operator": "gte",
        "value": 20.0,
        "window": "30d",
        "filters": {"direction": "INBOUND", "transaction_type": "finance", "subject_vendor_data": "__current__", "currency": "EUR"},
    }, {
        "metric": "max",
        "field": "amount",
        "operator": "lt",
        "value": 10000.0,
        "window": "30d",
        "filters": {"direction": "INBOUND", "transaction_type": "finance", "subject_vendor_data": "__current__", "currency": "EUR"},
    }],
    actions=[{
        "type": "add_score",
        "value": 35,
    }],
)
print(result)

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

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

const result = await didit.transactions.rules.create({
  title: "Structuring - inbound (custom)",
  description: "20+ inbound EUR transfers, all under 10,000 EUR, 30 days",
  category: "finance",
  mode: "TEST",
  evaluation_mode: "ALL",
  scope: {
    transaction_types: ["finance"],
    directions: ["INBOUND"],
  },
  conditions: [{
    field: "currency",
    operator: "eq",
    value: "EUR",
  }, {
    field: "amount",
    operator: "lt",
    value: 10000,
  }],
  aggregation: [{
    metric: "count",
    operator: "gte",
    value: 20.0,
    window: "30d",
    filters: { direction: "INBOUND", transaction_type: "finance", subject_vendor_data: "__current__", currency: "EUR" },
  }, {
    metric: "max",
    field: "amount",
    operator: "lt",
    value: 10000.0,
    window: "30d",
    filters: { direction: "INBOUND", transaction_type: "finance", subject_vendor_data: "__current__", currency: "EUR" },
  }],
  actions: [{
    type: "add_score",
    value: 35,
  }],
});
console.log(result);

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

result, err := client.Transactions.Rules.Create(ctx, didit.TransactionRuleCreateRequest{
	Title:          "Structuring - inbound (custom)",
	Description:    didit.String("20+ inbound EUR transfers, all under 10,000 EUR, 30 days"),
	Category:       "finance",
	Mode:           "TEST",
	EvaluationMode: didit.Some(didit.TransactionRuleCreateRequestEvaluationMode("ALL")),
	Scope: didit.Some(didit.TransactionRuleScopeParam{
		TransactionTypes: didit.Some([]string{"finance"}),
		Directions:       didit.Some([]didit.TransactionRuleScopeDirections{"INBOUND"}),
	}),
	Conditions: didit.Some([]didit.TransactionRuleConditionParam{{
		Field:    "currency",
		Operator: "eq",
		Value:    didit.Some[any]("EUR"),
	}, {
		Field:    "amount",
		Operator: "lt",
		Value:    didit.Some[any](10000),
	}}),
	Aggregation: didit.Some([]didit.TransactionRuleAggregationParam{{
		Metric:   didit.Some(didit.TransactionRuleAggregationMetric("count")),
		Operator: didit.Some(didit.TransactionRuleAggregationOperator("gte")),
		Value:    20.0,
		Window:   didit.String("30d"),
		Filters:  didit.Some(map[string]any{"direction": "INBOUND", "transaction_type": "finance", "subject_vendor_data": "__current__", "currency": "EUR"}),
	}, {
		Metric:   didit.Some(didit.TransactionRuleAggregationMetric("max")),
		Field:    didit.String("amount"),
		Operator: didit.Some(didit.TransactionRuleAggregationOperator("lt")),
		Value:    10000.0,
		Window:   didit.String("30d"),
		Filters:  didit.Some(map[string]any{"direction": "INBOUND", "transaction_type": "finance", "subject_vendor_data": "__current__", "currency": "EUR"}),
	}}),
	Actions: didit.Some([]didit.TransactionRuleActionParam{{
		Type:  "add_score",
		Value: didit.Some[any](35),
	}}),
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("%+v\n", result)

import java.util.List;
import java.util.Map;
import me.didit.Didit;
import me.didit.types.TransactionRuleAction;
import me.didit.types.TransactionRuleActionAddScore;
import me.didit.types.TransactionRuleAggregation;
import me.didit.types.TransactionRuleCondition;
import me.didit.types.TransactionRuleCreateRequest;
import me.didit.types.TransactionRuleScope;

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

var result = client.transactions().rules().create(TransactionRuleCreateRequest.builder()
        .title("Structuring - inbound (custom)")
        .description("20+ inbound EUR transfers, all under 10,000 EUR, 30 days")
        .category("finance")
        .mode(TransactionRuleCreateRequest.Mode.of("TEST"))
        .evaluationMode(TransactionRuleCreateRequest.EvaluationMode.of("ALL"))
        .scope(TransactionRuleScope.builder()
                .transactionTypes(List.of("finance"))
                .directions(List.of(TransactionRuleScope.Directions.of("INBOUND")))
                .build())
        .conditions(List.of(
                TransactionRuleCondition.builder()
                        .field("currency")
                        .operator(TransactionRuleCondition.Operator.of("eq"))
                        .value("EUR")
                        .build(),
                TransactionRuleCondition.builder()
                        .field("amount")
                        .operator(TransactionRuleCondition.Operator.of("lt"))
                        .value(10000)
                        .build()))
        .aggregation(List.of(
                TransactionRuleAggregation.builder()
                        .metric(TransactionRuleAggregation.Metric.of("count"))
                        .operator(TransactionRuleAggregation.Operator.of("gte"))
                        .value(20.0)
                        .window("30d")
                        .filters(Map.of("direction", "INBOUND", "transaction_type", "finance", "subject_vendor_data", "__current__", "currency", "EUR"))
                        .build(),
                TransactionRuleAggregation.builder()
                        .metric(TransactionRuleAggregation.Metric.of("max"))
                        .field("amount")
                        .operator(TransactionRuleAggregation.Operator.of("lt"))
                        .value(10000.0)
                        .window("30d")
                        .filters(Map.of("direction", "INBOUND", "transaction_type", "finance", "subject_vendor_data", "__current__", "currency", "EUR"))
                        .build()))
        .actions(List.of(TransactionRuleAction.ofAddScore(TransactionRuleActionAddScore.builder()
                .type(TransactionRuleActionAddScore.Type.of("add_score"))
                .value(35L)
                .build())))
        .build());
System.out.println(result);

<?php

require 'vendor/autoload.php';

use Didit\DiditClient;

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

$result = $didit->transactions->rules->create([
    'title' => 'Structuring - inbound (custom)',
    'description' => '20+ inbound EUR transfers, all under 10,000 EUR, 30 days',
    'category' => 'finance',
    'mode' => 'TEST',
    'evaluation_mode' => 'ALL',
    'scope' => [
        'transaction_types' => ['finance'],
        'directions' => ['INBOUND'],
    ],
    'conditions' => [[
        'field' => 'currency',
        'operator' => 'eq',
        'value' => 'EUR',
    ], [
        'field' => 'amount',
        'operator' => 'lt',
        'value' => 10000,
    ]],
    'aggregation' => [[
        'metric' => 'count',
        'operator' => 'gte',
        'value' => 20.0,
        'window' => '30d',
        'filters' => ['direction' => 'INBOUND', 'transaction_type' => 'finance', 'subject_vendor_data' => '__current__', 'currency' => 'EUR'],
    ], [
        'metric' => 'max',
        'field' => 'amount',
        'operator' => 'lt',
        'value' => 10000.0,
        'window' => '30d',
        'filters' => ['direction' => 'INBOUND', 'transaction_type' => 'finance', 'subject_vendor_data' => '__current__', 'currency' => 'EUR'],
    ]],
    'actions' => [[
        'type' => 'add_score',
        'value' => 35,
    ]],
]);
print_r($result->toArray());

require "didit"

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

result = didit.transactions.rules.create(
  title: "Structuring - inbound (custom)",
  description: "20+ inbound EUR transfers, all under 10,000 EUR, 30 days",
  category: "finance",
  mode: "TEST",
  evaluation_mode: "ALL",
  scope: {
    transaction_types: ["finance"],
    directions: ["INBOUND"],
  },
  conditions: [{
    field: "currency",
    operator: "eq",
    value: "EUR",
  }, {
    field: "amount",
    operator: "lt",
    value: 10000,
  }],
  aggregation: [{
    metric: "count",
    operator: "gte",
    value: 20.0,
    window: "30d",
    filters: { direction: "INBOUND", transaction_type: "finance", subject_vendor_data: "__current__", currency: "EUR" },
  }, {
    metric: "max",
    field: "amount",
    operator: "lt",
    value: 10000.0,
    window: "30d",
    filters: { direction: "INBOUND", transaction_type: "finance", subject_vendor_data: "__current__", currency: "EUR" },
  }],
  actions: [{
    type: "add_score",
    value: 35,
  }]
)
puts result.to_h

using System;
using System.Collections.Generic;
using System.Text.Json;
using Didit;

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

var result = await client.Transactions.Rules.CreateAsync(new TransactionRuleCreateRequest
{
    Title = "Structuring - inbound (custom)",
    Description = "20+ inbound EUR transfers, all under 10,000 EUR, 30 days",
    Category = "finance",
    Mode = "TEST",
    EvaluationMode = new TransactionRuleCreateRequestEvaluationMode("ALL"),
    Scope = new TransactionRuleScope
    {
        TransactionTypes = new string[] { "finance" },
        Directions = new TransactionRuleScopeDirections[] { "INBOUND" },
    },
    Conditions = new TransactionRuleCondition[]
    {
        new()
        {
            Field = "currency",
            Operator = "eq",
            Value = "EUR",
        },
        new()
        {
            Field = "amount",
            Operator = "lt",
            Value = 10000,
        },
    },
    Aggregation = new TransactionRuleAggregation[]
    {
        new()
        {
            Metric = new TransactionRuleAggregationMetric("count"),
            Operator = new TransactionRuleAggregationOperator("gte"),
            Value = 20.0,
            Window = "30d",
            Filters = new Dictionary<string, object> { ["direction"] = "INBOUND", ["transaction_type"] = "finance", ["subject_vendor_data"] = "__current__", ["currency"] = "EUR" },
        },
        new()
        {
            Metric = new TransactionRuleAggregationMetric("max"),
            Field = "amount",
            Operator = new TransactionRuleAggregationOperator("lt"),
            Value = 10000.0,
            Window = "30d",
            Filters = new Dictionary<string, object> { ["direction"] = "INBOUND", ["transaction_type"] = "finance", ["subject_vendor_data"] = "__current__", ["currency"] = "EUR" },
        },
    },
    Actions = new TransactionRuleAction[]
    {
        new()
        {
            Type = new TransactionRuleActionType("add_score"),
            Value = 35,
        },
    },
});
Console.WriteLine(JsonSerializer.Serialize(result));

{
  "uuid": "3c90c3cc-0d44-4b50-8888-8dd25736052a",
  "title": "<string>",
  "description": "<string>",
  "category": "<string>",
  "mode": "ACTIVE",
  "evaluation_mode": "ALL",
  "scope": {
    "transaction_types": [
      "<string>"
    ],
    "directions": [
      "INBOUND"
    ],
    "action_types": [
      "<string>"
    ]
  },
  "conditions": [
    {
      "field": "<string>",
      "operator": "eq",
      "value": "<unknown>",
      "value_type": "list",
      "score": 50,
      "group_index": 123,
      "group_logic": "AND",
      "groups_logic": "OR"
    }
  ],
  "aggregation": [
    {
      "value": 123,
      "metric": "count",
      "field": "amount",
      "operator": "eq",
      "window": "1d",
      "filters": {}
    }
  ],
  "actions": [
    {
      "type": "add_score",
      "value": 123
    }
  ],
  "metadata": {},
  "severity": "UNKNOWN",
  "source": "PRESET",
  "library_key": "<string>",
  "latest_triggered_at": "2023-11-07T05:31:56Z",
  "run_count": 123,
  "approved_count": 123,
  "reviewed_count": 123,
  "declined_count": 123,
  "awaiting_user_count": 123,
  "approved_pct": 123,
  "reviewed_pct": 123,
  "declined_pct": 123,
  "created_at": "2023-11-07T05:31:56Z",
  "updated_at": "2023-11-07T05:31:56Z"
}

{
  "title": [
    "A rule with this name already exists."
  ]
}