> ## Documentation Index
> Fetch the complete documentation index at: https://docs.didit.me/llms.txt
> Use this file to discover all available pages before exploring further.

# केस ब्लूप्रिंट बनाने का API

> Didit में केस ब्लूप्रिंट बनाएं: असाइनमेंट विधि, एस्केलेशन, ट्रांसफ़र, 4-eyes चेकर जोड़ी, अनिवार्य समाधान नोट और केस सामग्री के 6 अनुभाग।



केस ब्लूप्रिंट बनाने का API प्रॉम्प्ट
        प्रॉम्प्ट को क्लिपबोर्ड पर कॉपी करें



      
      

\<pre>

\`Create a case blueprint through the Management API.

Endpoint:
POST https://verification.didit.me/v3/organization/{organization_id}/application/{application_id}/cases/blueprints/

Authentication:
Use the x-api-key header with my Didit API key.

Request body:
\{
"name": "AML investigation",                    // required, max 24 chars
"description": "...",                            // optional
"assignee_pool": ["<user-uuid>"],                 // required, at least 1 - "Pick at least one assignee" otherwise
"assignment_method": "AUTOMATIC",                 // optional, MANUAL|AUTOMATIC, default MANUAL
"max_active_cases": 15,                           // optional - AUTOMATIC threshold
"escalation_enabled": false,                      // optional
"escalation_blueprint": "<blueprint-uuid>",       // optional - set it alongside escalation_enabled; the escalate action fails with 400 until both are set
"transfer_enabled": false,                        // optional
"four_eyes_checker_blueprint": "<blueprint-uuid>", // optional - setting this enables 4-eyes
"require_resolution_note": true,                  // optional
"content_config": {"aml_control": {"enabled": true, "financial": true}},  // optional, six sections
"is_active": true                                 // optional, default true
}

content_config sections: checklist (enabled, optional, items[]), aml_control (enabled, financial, identity), identity (enabled, personal_information, applicant_tags, contact_information, risk_overview, poi_documents, poa_documents), verifications (enabled, summary), reporting (enabled, fiu_reports), financial (enabled, payment_methods, transactions). Unknown sections/keys are rejected with 400.

Example call:
curl -X POST "https://verification.didit.me/v3/organization/{organization_id}/application/{application_id}/cases/blueprints/" \
-H "x-api-key: YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{"name": "AML investigation", "assignee_pool": ["<uuid>"]}'

Response 201: CaseBlueprintDetail.

Failure modes:
\- 400 - name over 24 chars, empty assignee_pool, unknown content_config key, or escalation_blueprint/four_eyes_checker_blueprint not found in this application or self-referencing.
\- 401/403 - auth/permission errors (requires write:cases).

For the full integration shape, see /integration/integration-prompt.`

\</pre>



      
      

यहाँ पेस्ट करें

ब्लूप्रिंट बनाएँ। `content_config` की सख्ती से जाँच होती है: केवल छह ज्ञात सेक्शन और उनकी दस्तावेज़ीकृत कुंजियाँ ही स्वीकार होती हैं, इसलिए कोई टाइपो 400 लौटाता है और चुपचाप अनदेखा नहीं किया जाता।## संबंधित- [केस ब्लूप्रिंट सूचीबद्ध करें](https://docs.didit.me/hi/management-api/case-blueprints/list.md)
- [ब्लूप्रिंट प्रीसेट इंस्टॉल करें](https://docs.didit.me/hi/management-api/case-blueprints/install-presets.md)
- [ब्लूप्रिंट (कंसोल)](https://docs.didit.me/hi/console/case-management/blueprints.md)


## OpenAPI

````yaml hi/openapi-25.json POST /v3/organization/{organization_id}/application/{application_id}/cases/blueprints/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: पहचान सत्यापन API। x-api-key हेडर के साथ प्रमाणीकृत करें।
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/organization/{organization_id}/application/{application_id}/cases/blueprints/:
    post:
      tags:
        - Case Blueprints
      summary: ब्लूप्रिंट बनाएं
      description: >-
        एक केस ब्लूप्रिंट बनाएँ: सामान्य सेटिंग्स (असाइनमेंट, एस्केलेशन,
        ट्रांसफर, 4-आईज़ पेयरिंग) और साथ ही content_config, वे छह सेक्शन जो केस
        पेज को संचालित करते हैं। एक अप्रकाशित ड्राफ्ट बनाने के लिए publish=false
        सेट करें; पब्लिश इसका पहला लाइव संस्करण बनाता है। कभी प्रकाशित न किए गए
        ड्राफ्ट को डिस्कार्ड करने से वह हटा दिया जाता है।
      operationId: create_case_blueprint
      parameters:
        - name: organization_id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: संगठन UUID।
        - name: application_id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: एप्लिकेशन UUID।
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - name
                - assignee_pool
              properties:
                name:
                  type: string
                  maxLength: 24
                  description: अधिकतम 24 वर्ण, उदाहरण के लिए "AML investigation"।
                description:
                  type: string
                  nullable: true
                assignee_pool:
                  type: array
                  items:
                    type: string
                    format: uuid
                  minItems: 1
                  description: >-
                    उपयोगकर्ता UUIDs की सूची। खाली सरणियाँ "Pick at least one
                    assignee" के साथ अस्वीकृत कर दी जाती हैं।
                assignment_method:
                  type: string
                  enum:
                    - MANUAL
                    - AUTOMATIC
                  default: MANUAL
                max_active_cases:
                  type: integer
                  nullable: true
                  minimum: 1
                  description: >-
                    स्वचालित-मोड थ्रेशोल्ड: "इस ब्लूप्रिंट के N से कम केस असाइन
                    किए गए हैं"।
                escalation_enabled:
                  type: boolean
                  default: false
                escalation_blueprint:
                  type: string
                  format: uuid
                  nullable: true
                  description: >-
                    लक्षित ब्लूप्रिंट UUID। सहेजते समय लागू नहीं किया जाता है,
                    लेकिन जब तक escalation_enabled और escalation_blueprint दोनों
                    सेट नहीं होते हैं, तब तक एस्केलेट कार्रवाई 400 के साथ विफल
                    हो जाती है।
                transfer_enabled:
                  type: boolean
                  default: false
                four_eyes_checker_blueprint:
                  type: string
                  format: uuid
                  nullable: true
                  description: >-
                    इसे सेट करने से 4-eyes समीक्षा सक्षम होती है: इस ब्लूप्रिंट
                    के समाधान चेकर ब्लूप्रिंट की कतार में रखे जाते हैं।
                require_resolution_note:
                  type: boolean
                  default: false
                content_config:
                  $ref: '#/components/schemas/CaseContentConfig'
                is_active:
                  type: boolean
                  default: true
                default_deadline_hours:
                  type: integer
                  nullable: true
                  minimum: 1
                  maximum: 8760
                  description: >-
                    नए खोले गए केस के लिए डिफ़ॉल्ट समय-सीमा। मौजूदा केस की
                    समय-सीमा अपरिवर्तित रहती है।
                publish:
                  type: boolean
                  writeOnly: true
                  default: true
                  description: >-
                    कभी प्रकाशित न किए गए ड्राफ़्ट को सहेजने के लिए false सेट
                    करें। रिकॉर्ड वर्ज़न 0 पर तब तक निष्क्रिय रहता है जब तक कि
                    ड्राफ़्ट को स्पष्ट रूप से प्रकाशित नहीं किया जाता। इस फ़ील्ड
                    को छोड़ने से मौजूदा इंटीग्रेशन के लिए तत्काल निर्माण
                    सुरक्षित रहता है।
            example:
              name: AML investigation
              assignee_pool:
                - 9a000000-0000-4000-8000-0000000000aa
              assignment_method: AUTOMATIC
              max_active_cases: 15
              require_resolution_note: true
              content_config:
                aml_control:
                  enabled: true
                  financial: true
                  identity: false
      responses:
        '201':
          description: Blueprint बनाया गया।
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CaseBlueprintDetail'
        '400':
          description: >-
            नाम 24 वर्णों से अधिक लंबा है, assignee_pool खाली है, या
            क्रॉस-रेफ़रंस किया गया ब्लूप्रिंट (एस्केलेशन/चेकर) नहीं मिला।
          content:
            application/json:
              schema:
                type: object
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X POST
            'https://verification.didit.me/v3/organization/11111111-2222-3333-4444-555555555555/application/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/cases/blueprints/'
            \
              -H 'x-api-key: YOUR_API_KEY' \
              -H 'Content-Type: application/json' \
              -d '{"name": "AML investigation", "assignee_pool": ["9a000000-0000-4000-8000-0000000000aa"], "assignment_method": "AUTOMATIC", "max_active_cases": 15, "require_resolution_note": true, "content_config": {"aml_control": {"enabled": true, "financial": true, "identity": false}}}'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID
            # and DIDIT_APPLICATION_ID.
            client = Didit()

            result = client.cases.blueprints.create(
                name="AML investigation",
                assignee_pool=["9a000000-0000-4000-8000-0000000000aa"],
                assignment_method="AUTOMATIC",
                max_active_cases=15,
                require_resolution_note=True,
                content_config={
                    "aml_control": {
                        "enabled": True,
                        "financial": True,
                        "identity": False,
                    },
                },
            )
            print(result)
        - lang: javascript
          label: Node.js
          source: |-
            import Didit from "@didit-protocol/sdk-node";

            // Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID
            // and DIDIT_APPLICATION_ID.
            const didit = new Didit();

            const result = await didit.cases.blueprints.create({
              name: "AML investigation",
              assignee_pool: ["9a000000-0000-4000-8000-0000000000aa"],
              assignment_method: "AUTOMATIC",
              max_active_cases: 15,
              require_resolution_note: true,
              content_config: {
                aml_control: {
                  enabled: true,
                  financial: true,
                  identity: false,
                },
              },
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID\n// and DIDIT_APPLICATION_ID.\nclient := didit.NewClient()\n\nresult, err := client.Cases.Blueprints.Create(ctx, didit.CasesBlueprintsCreateParams{\n\tName:                  \"AML investigation\",\n\tAssigneePool:          []string{\"9a000000-0000-4000-8000-0000000000aa\"},\n\tAssignmentMethod:      didit.Some(didit.CasesBlueprintsCreateParamsAssignmentMethod(\"AUTOMATIC\")),\n\tMaxActiveCases:        didit.Int(15),\n\tRequireResolutionNote: didit.Bool(true),\n\tContentConfig: didit.Some(didit.CaseContentConfigParam{\n\t\tAMLControl: didit.Some(didit.CaseContentConfigParamAMLControl{\n\t\t\tEnabled:   didit.Bool(true),\n\t\t\tFinancial: didit.Bool(true),\n\t\t\tIdentity:  didit.Bool(false),\n\t\t}),\n\t}),\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import java.util.List;

            import me.didit.Didit;

            import me.didit.types.CaseContentConfig;

            import me.didit.types.CasesBlueprintsCreateParams;


            // Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID

            // and DIDIT_APPLICATION_ID.

            Didit client = new Didit();


            var result =
            client.cases().blueprints().create(CasesBlueprintsCreateParams.builder()
                    .name("AML investigation")
                    .assigneePool(List.of("9a000000-0000-4000-8000-0000000000aa"))
                    .assignmentMethod(CasesBlueprintsCreateParams.AssignmentMethod.of("AUTOMATIC"))
                    .maxActiveCases(15L)
                    .requireResolutionNote(true)
                    .contentConfig(CaseContentConfig.builder()
                            .amlControl(CaseContentConfig.AmlControl.builder()
                                    .enabled(true)
                                    .financial(true)
                                    .identity(false)
                                    .build())
                            .build())
                    .build());
            System.out.println(result);
        - lang: php
          label: PHP
          source: |-
            <?php

            require 'vendor/autoload.php';

            use Didit\DiditClient;

            // Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID
            // and DIDIT_APPLICATION_ID.
            $didit = new DiditClient();

            $result = $didit->cases->blueprints->create([
                'name' => 'AML investigation',
                'assignee_pool' => ['9a000000-0000-4000-8000-0000000000aa'],
                'assignment_method' => 'AUTOMATIC',
                'max_active_cases' => 15,
                'require_resolution_note' => true,
                'content_config' => [
                    'aml_control' => [
                        'enabled' => true,
                        'financial' => true,
                        'identity' => false,
                    ],
                ],
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

            # Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID
            # and DIDIT_APPLICATION_ID.
            didit = Didit::Client.new

            result = didit.cases.blueprints.create(
              name: "AML investigation",
              assignee_pool: ["9a000000-0000-4000-8000-0000000000aa"],
              assignment_method: "AUTOMATIC",
              max_active_cases: 15,
              require_resolution_note: true,
              content_config: {
                aml_control: {
                  enabled: true,
                  financial: true,
                  identity: false,
                },
              }
            )
            puts result.to_h
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID

            // and DIDIT_APPLICATION_ID.

            using var client = new DiditClient();


            var result = await client.Cases.Blueprints.CreateAsync(new
            CasesBlueprintsCreateParams

            {
                Name = "AML investigation",
                AssigneePool = new string[] { "9a000000-0000-4000-8000-0000000000aa" },
                AssignmentMethod = new CasesBlueprintsCreateParamsAssignmentMethod("AUTOMATIC"),
                MaxActiveCases = 15,
                RequireResolutionNote = true,
                ContentConfig = new CaseContentConfig
                {
                    AmlControl = new CaseContentConfigAmlControl
                    {
                        Enabled = true,
                        Financial = true,
                        Identity = false,
                    },
                },
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    CaseContentConfig:
      type: object
      description: >-
        छह टॉगल करने योग्य अनुभाग जो यह तय करते हैं कि केस पेज पर कौन से टैब और
        फ़ील्ड दिखाई देंगे। अज्ञात अनुभागों या कुंजियों को अस्वीकार कर दिया जाता
        है।
      properties:
        checklist:
          type: object
          properties:
            enabled:
              type: boolean
            optional:
              type: boolean
              description: >-
                true होने पर, किसी केस को अधूरी चेकलिस्ट मदों के साथ भी हल किया
                जा सकता है।
            items:
              type: array
              items:
                type: object
                properties:
                  label:
                    type: string
                    maxLength: 255
                  order:
                    type: integer
        aml_control:
          type: object
          properties:
            enabled:
              type: boolean
            financial:
              type: boolean
            identity:
              type: boolean
        identity:
          type: object
          properties:
            enabled:
              type: boolean
            personal_information:
              type: boolean
            applicant_tags:
              type: boolean
            contact_information:
              type: boolean
            risk_overview:
              type: boolean
            poi_documents:
              type: boolean
            poa_documents:
              type: boolean
        verifications:
          type: object
          properties:
            enabled:
              type: boolean
            summary:
              type: boolean
        reporting:
          type: object
          properties:
            enabled:
              type: boolean
            fiu_reports:
              type: boolean
        financial:
          type: object
          properties:
            enabled:
              type: boolean
            payment_methods:
              type: boolean
            transactions:
              type: boolean
    CaseBlueprintDetail:
      type: object
      properties:
        uuid:
          type: string
          format: uuid
        name:
          type: string
          maxLength: 24
        description:
          type: string
          nullable: true
        assignment_method:
          type: string
          enum:
            - MANUAL
            - AUTOMATIC
        assignee_pool:
          type: array
          items:
            type: string
            format: uuid
        max_active_cases:
          type: integer
          nullable: true
        escalation_enabled:
          type: boolean
        transfer_enabled:
          type: boolean
        require_resolution_note:
          type: boolean
        is_active:
          type: boolean
        preset_key:
          type: string
          nullable: true
        created_at:
          type: string
          format: date-time
        escalation_blueprint:
          type: string
          format: uuid
          nullable: true
        escalation_blueprint_name:
          type: string
          nullable: true
        four_eyes_checker_blueprint:
          type: string
          format: uuid
          nullable: true
        four_eyes_checker_blueprint_name:
          type: string
          nullable: true
        content_config:
          type: object
          description: >-
            छह टॉगल करने योग्य अनुभाग जो यह तय करते हैं कि केस पेज पर कौन से टैब
            और फ़ील्ड दिखाई देंगे। अज्ञात अनुभागों या कुंजियों को अस्वीकार कर
            दिया जाता है।
          properties:
            checklist:
              type: object
              properties:
                enabled:
                  type: boolean
                optional:
                  type: boolean
                  description: >-
                    true होने पर, किसी केस को अधूरी चेकलिस्ट मदों के साथ भी हल
                    किया जा सकता है।
                items:
                  type: array
                  items:
                    type: object
                    properties:
                      label:
                        type: string
                        maxLength: 255
                      order:
                        type: integer
            aml_control:
              type: object
              properties:
                enabled:
                  type: boolean
                financial:
                  type: boolean
                identity:
                  type: boolean
            identity:
              type: object
              properties:
                enabled:
                  type: boolean
                personal_information:
                  type: boolean
                applicant_tags:
                  type: boolean
                contact_information:
                  type: boolean
                risk_overview:
                  type: boolean
                poi_documents:
                  type: boolean
                poa_documents:
                  type: boolean
            verifications:
              type: object
              properties:
                enabled:
                  type: boolean
                summary:
                  type: boolean
            reporting:
              type: object
              properties:
                enabled:
                  type: boolean
                fiu_reports:
                  type: boolean
            financial:
              type: object
              properties:
                enabled:
                  type: boolean
                payment_methods:
                  type: boolean
                transactions:
                  type: boolean
        creation_sources:
          type: array
          description: वर्तमान में इस ब्लूप्रिंट में नए केस रूट करने वाले कनेक्टर्स।
          items:
            type: object
            properties:
              kind:
                type: string
                enum:
                  - aml
                  - rule
                  - workflow
              id:
                type: string
              name:
                type: string
        receives_escalation_from:
          type: array
          description: अन्य ब्लूप्रिंट जिनका Escalation लक्ष्य इस पर इंगित करता है।
          items:
            type: object
            properties:
              id:
                type: string
              name:
                type: string
        updated_at:
          type: string
          format: date-time
        version:
          type: integer
          readOnly: true
        default_deadline_hours:
          type: integer
          nullable: true
          minimum: 1
          maximum: 8760
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        आपकी एप्लिकेशन की API कुंजी, Business Console में Developers -> API keys
        से। प्राथमिक कुंजी के पास पूर्ण एक्सेस होता है। एक नामित कुंजी को स्कोप
        किया जा सकता है: प्रति संसाधन none, read या write, कुछ वर्कफ़्लो या
        स्वीकृत सत्रों तक सीमित, IP पतों की सूची तक सीमित, और समाप्ति तिथि तक
        सीमित। 401 का अर्थ है कि कुंजी गलत है, निरस्त कर दी गई है या उसकी
        समय-सीमा समाप्त हो गई है; 403 का अर्थ है कि कोई कुंजी नहीं भेजी गई थी,
        कुंजी के पास इस संसाधन या कार्रवाई का एक्सेस नहीं है, या अनुरोध उसकी IP
        सूची से बाहर के पते से आया था; सत्र रूट पर 404 का अर्थ है कि सत्र कुंजी
        के वर्कफ़्लो या स्थितियों से बाहर है। मीडिया एक्सेस के बिना एक कुंजी को
        छवि, वीडियो और PDF URL null के रूप में प्राप्त होते हैं, और सत्र write
        के बिना एक कुंजी को सत्र लिंक और token null के रूप में प्राप्त होते हैं।
        देखें https://docs.didit.me/console/api-keys।

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.