---
title: "Create custom project"
method: POST
path: "/rest/api/3/project-template"
tags: ["Project templates"]
---

# Create custom project

`POST /rest/api/3/project-template`

Creates a project based on a custom template provided in the request.

The request body should contain the project details and the capabilities that comprise the project:

 *  `details` \- represents the project details settings
 *  `template` \- represents a list of capabilities responsible for creating specific parts of a project

A capability is defined as a unit of configuration for the project you want to create.

This operation is:

 *  [asynchronous](#async). Follow the `Location` link in the response header to determine the status of the task and use [Get task](#api-rest-api-3-task-taskId-get) to obtain subsequent updates.

***Note: This API is only supported for Jira Enterprise edition.***

**[Permissions](#permissions) required:** *Administer Jira* [global permission](https://confluence.atlassian.com/x/x4dKLg).

## Request body

- ProjectCustomTemplateCreateRequestDTO — Request to create a project using a custom template
  - `details` CustomTemplatesProjectDetails — Project Details
    - `accessLevel` 'open' | 'limited' | 'private' | 'free' — The access level of the project. Only used by team-managed project
    - `additionalProperties` object — Additional properties of the project
    - `assigneeType` 'PROJECT_DEFAULT' | 'COMPONENT_LEAD' | 'PROJECT_LEAD' | 'UNASSIGNED' — The default assignee when creating issues in the project
    - `avatarId` integer — The ID of the project's avatar. Use the \[Get project avatars\](\#api-rest-api-3-project-projectIdOrKey-avatar-get) operation to list the available avatars in a project.
    - `categoryId` integer — The ID of the project's category. A complete list of category IDs is found using the [Get all project categories](#api-rest-api-3-projectCategory-get) operation.
    - `description` string — Brief description of the project
    - `enableComponents` boolean — Whether components are enabled for the project. Only used by company-managed project
    - `key` string — Project keys must be unique and start with an uppercase letter followed by one or more uppercase alphanumeric characters. The maximum length is 10 characters.
    - `language` string — The default language for the project
    - `leadAccountId` string — The account ID of the project lead. Either `lead` or `leadAccountId` must be set when creating a project. Cannot be provided with `lead`.
    - `name` string — Name of the project
    - `url` string — A link to information about this project, such as project documentation
  - `template` CustomTemplateRequestDTO — The specific request object for creating a project with template.
    - `boardFeatures` BoardFeaturesPayload, nullable — Configuration of features for one or more boards. Replaces the deprecated features field on BoardPayload
      - `boardFeatures` object — A map of board PCRIs to the list of features to enable on each board.
    - `boards` BoardsPayload, nullable
      - `boards` BoardPayload[] — The boards to be associated with the project.
        - `boardFilterJQL` string — Takes in a JQL string to create a new filter. If no value is provided, it'll default to a JQL filter for the project creating
        - `cardColorStrategy` 'ISSUE_TYPE' | 'REQUEST_TYPE' | 'ASSIGNEE' | 'PRIORITY' | 'NONE' | 'CUSTOM' — Card color settings of the board
        - `cardLayout` CardLayout — Card layout configuration.
          - `showDaysInColumn` true | false — Whether to show days in column
        - `cardLayouts` CardLayoutField[] — Card layout settings of the board
          - `fieldId` string
          - `id` integer
          - `mode` 'PLAN' | 'WORK'
          - `position` integer
        - `columns` BoardColumnPayload[] — The columns of the board
          - `maximumIssueConstraint` integer — The maximum issue constraint for the column
          - `minimumIssueConstraint` integer — The minimum issue constraint for the column
          - `name` string — The name of the column
          - `statusIds` ProjectCreateResourceIdentifier[] — The status IDs for the column
            - `anID` boolean
            - `areference` boolean
            - `entityId` string
            - `entityType` string
            - `id` string
            - `type` 'id' | 'ref'
        - `enableCardCover` boolean — Whether to enable the card cover option on this board
        - `features` BoardFeaturePayload[] — Feature settings for the board. Deprecated: use boardFeatures capability instead.
          - `featureKey` 'ESTIMATION' | 'SPRINTS' — The key of the feature
          - `state` true | false — Whether the feature should be turned on or off
        - `name` string — The name of the board
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `quickFilters` QuickFilterPayload[] — The quick filters for the board.
          - `description` string — The description of the quick filter
          - `jqlQuery` string — The jql query for the quick filter
          - `name` string — The name of the quick filter
        - `supportsSprint` boolean — Whether sprints are supported on the board
        - `swimlanes` SwimlanesPayload — The payload for customising a swimlanes on a board
          - `customSwimlanes` SwimlanePayload[] — The custom swimlane definitions.
            - `description` string — The description of the quick filter
            - `jqlQuery` string — The jql query for the quick filter
            - `name` string — The name of the quick filter
          - `defaultCustomSwimlaneName` string — The name of the custom swimlane to use for work items that don't match any other swimlanes.
          - `swimlaneStrategy` 'none' | 'custom' | 'parentChild' | 'assignee' | 'assigneeUnassignedFirst' | 'epic' | 'project' | 'issueparent' | 'issuechildren' | 'request_type' — The swimlane strategy for the board.
        - `workingDaysConfig` WorkingDaysConfig — Working days configuration
          - `friday` boolean
          - `id` integer
          - `monday` boolean
          - `nonWorkingDays` NonWorkingDay[]
            - `id` integer
            - `iso8601Date` string
          - `saturday` boolean
          - `sunday` boolean
          - `thursday` boolean
          - `timezoneId` string
          - `tuesday` boolean
          - `wednesday` boolean
    - `field` FieldCapabilityPayload, nullable — Defines the payload for the fields, screens, screen schemes, issue type screen schemes, field layouts, and field layout schemes
      - `customFieldDefinitions` CustomFieldPayload[], nullable — The custom field definitions. See https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issue-fields/\#api-rest-api-3-field-post
        - `cfType` string — The type of the custom field
        - `description` string — The description of the custom field
        - `name` string — The name of the custom field
        - `onConflict` 'FAIL' | 'USE' | 'NEW' — The strategy to use when there is a conflict with an existing custom field. FAIL - Fail execution, this always needs to be unique; USE - Use the existing entity and ignore new entity parameters
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `scope` 'GLOBAL' | 'TEMPLATE' | 'PROJECT' — Allows an overwrite to declare the new Custom Field to be created as a GLOBAL-scoped field. Leave this as empty or null to use the project's default scope.
        - `searcherKey` string — The searcher key of the custom field
      - `fieldLayoutScheme` FieldLayoutSchemePayload, nullable — Deprecated use [fieldAssociationScheme](https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-field-schemes/#api-group-field-schemes) instead Defines the payload for the field layout schemes. See [ Field configuration scheme](https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issue-field-configurations/#api-rest-api-3-fieldconfigurationscheme-post). [ How to configure a field configuration scheme](https://support.atlassian.com/jira-cloud-administration/docs/configure-a-field-configuration-scheme/).
        - `defaultFieldLayout` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `description` string — The description of the field layout scheme
        - `explicitMappings` object — There is a default configuration "fieldlayout" that is applied to all issue types using this scheme that don't have an explicit mapping users can create (or re-use existing) configurations for other issue types and map them to this scheme
        - `name` string — The name of the field layout scheme
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
      - `fieldLayouts` FieldLayoutPayload[], nullable — The field layouts configuration.
        - `configuration` FieldLayoutConfiguration[] — The field layout configuration. See https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issue-field-configurations/\#api-rest-api-3-fieldconfiguration-post
          - `field` boolean — Whether to show the field
          - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
            - `anID` boolean
            - `areference` boolean
            - `entityId` string
            - `entityType` string
            - `id` string
            - `type` 'id' | 'ref'
          - `required` boolean — Whether the field is required
        - `description` string — The description of the field layout
        - `name` string — The name of the field layout
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
      - `fieldScheme` FieldSchemePayload, nullable — Defines the payload to configure the field scheme for a project. See [Field schemes](https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-field-schemes/#api-group-field-schemes).
        - `description` string — The description of the field scheme
        - `items` FieldAssociationItemPayload[] — The field association items for this field scheme.
          - `description` string — The description of the field association item
          - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
            - `anID` boolean
            - `areference` boolean
            - `entityId` string
            - `entityType` string
            - `id` string
            - `type` 'id' | 'ref'
          - `qualifierId` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
            - `anID` boolean
            - `areference` boolean
            - `entityId` string
            - `entityType` string
            - `id` string
            - `type` 'id' | 'ref'
          - `qualifierType` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
            - `anID` boolean
            - `areference` boolean
            - `entityId` string
            - `entityType` string
            - `id` string
            - `type` 'id' | 'ref'
          - `rendererType` string — The renderer type of the field
          - `required` boolean — Whether the field is required
        - `name` string — The name of the field scheme
        - `onConflict` 'FAIL' | 'USE' | 'NEW' — The strategy to use when there is a conflict with an existing field scheme. FAIL - Fail execution, this always needs to be unique; USE - Use the existing entity and ignore new entity parameters
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
      - `issueLayouts` IssueLayoutPayload[], nullable — The issue layouts configuration
        - `containerId` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `issueLayoutType` 'ISSUE_VIEW' | 'ISSUE_CREATE' | 'REQUEST_FORM' — The issue layout type
        - `items` IssueLayoutItemPayload[] — The configuration of items in the issue layout
          - `itemKey` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
            - `anID` boolean
            - `areference` boolean
            - `entityId` string
            - `entityType` string
            - `id` string
            - `type` 'id' | 'ref'
          - `properties` object — Additional properties for this item. This field is only used when the type is FIELD.
          - `sectionType` 'content' | 'primaryContext' | 'secondaryContext' — The item section type
          - `type` 'FIELD' — The item type. Currently only support FIELD
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
      - `issueTypeScreenScheme` IssueTypeScreenSchemePayload, nullable — Defines the payload for the issue type screen schemes. See https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issue-type-screen-schemes/\#api-rest-api-3-issuetypescreenscheme-post
        - `defaultScreenScheme` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `description` string — The description of the issue type screen scheme
        - `explicitMappings` object — The IDs of the screen schemes for the issue type IDs and default. A default entry is required to create an issue type screen scheme, it defines the mapping for all issue types without a screen scheme.
        - `name` string — The name of the issue type screen scheme
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
      - `screenScheme` ScreenSchemePayload[], nullable — The screen schemes See https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-screen-schemes/\#api-rest-api-3-screenscheme-post
        - `defaultScreen` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `description` string — The description of the screen scheme
        - `name` string — The name of the screen scheme
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `screens` object — Similar to the field layout scheme those mappings allow users to set different screens for different operations: default - always there, applied to all operations that don't have an explicit mapping `create`, `view`, `edit` - specific operations that are available and users can assign a different screen for each one of them https://support.atlassian.com/jira-cloud-administration/docs/manage-screen-schemes/\#Associating-a-screen-with-an-issue-operation
      - `screens` ScreenPayload[], nullable — The screens. See https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-screens/\#api-rest-api-3-screens-post
        - `description` string — The description of the screen
        - `name` string — The name of the screen
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `tabs` TabPayload[] — The tabs of the screen. See https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-screen-tab-fields/\#api-rest-api-3-screens-screenid-tabs-tabid-fields-post
          - `fields` ProjectCreateResourceIdentifier[] — The list of resource identifier of the field associated to the tab. See https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-screen-tab-fields/\#api-rest-api-3-screens-screenid-tabs-tabid-fields-post
            - `anID` boolean
            - `areference` boolean
            - `entityId` string
            - `entityType` string
            - `id` string
            - `type` 'id' | 'ref'
          - `name` string — The name of the tab
    - `issueType` IssueTypeProjectCreatePayload, nullable — The payload for creating issue types in a project
      - `issueTypeHierarchy` IssueTypeHierarchyPayload[], nullable — Defines the issue type hierarhy to be created and used during this project creation. This will only add new levels if there isn't an existing level
        - `hierarchyLevel` integer — The hierarchy level of the issue type. 0, 1, 2, 3 .. n; Negative values for subtasks
        - `name` string — The name of the issue type
        - `onConflict` 'FAIL' | 'USE' | 'NEW' — The conflict strategy to use when the issue type already exists. FAIL - Fail execution, this always needs to be unique; USE - Use the existing entity and ignore new entity parameters
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
      - `issueTypeScheme` IssueTypeSchemePayload — The payload for creating issue type schemes
        - `defaultIssueTypeId` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `description` string, nullable — The description of the issue type scheme
        - `issueTypeIds` ProjectCreateResourceIdentifier[] — The issue type IDs for the issue type scheme
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `name` string — The name of the issue type scheme
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
      - `issueTypes` IssueTypePayload[], nullable — Only needed if you want to create issue types, you can otherwise use the ids of issue types in the scheme configuration
        - `avatarId` integer, nullable — The avatar ID of the issue type. Go to https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-avatars/\#api-rest-api-3-avatar-type-system-get to choose an avatarId existing in Jira
        - `description` string, nullable — The description of the issue type
        - `hierarchyLevel` integer — The hierarchy level of the issue type. 0, 1, 2, 3 .. n; Negative values for subtasks
        - `name` string — The name of the issue type
        - `onConflict` 'FAIL' | 'USE' | 'NEW' — The conflict strategy to use when the issue type already exists. FAIL - Fail execution, this always needs to be unique; USE - Use the existing entity and ignore new entity parameters
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
    - `notification` NotificationSchemePayload, nullable — The payload for creating a notification scheme. The user has to supply the ID for the default notification scheme. For CMP this is provided in the project payload and should be left empty, for TMP it's provided using this payload
      - `description` string — The description of the notification scheme
      - `name` string — The name of the notification scheme
      - `notificationSchemeEvents` NotificationSchemeEventPayload[] — The events and notifications for the notification scheme
        - `event` NotificationSchemeEventIDPayload — The event ID to use for reference in the payload
          - `id` string — The event ID to use for reference in the payload
        - `notifications` NotificationSchemeNotificationDetailsPayload[] — The configuration for notification recipents
          - `notificationType` string — The type of notification.
          - `parameter` string — The parameter of the notification, should be eiither null if not required, or PCRI.
      - `onConflict` 'FAIL' | 'USE' | 'NEW' — The strategy to use when there is a conflict with an existing entity
      - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
        - `anID` boolean
        - `areference` boolean
        - `entityId` string
        - `entityType` string
        - `id` string
        - `type` 'id' | 'ref'
    - `permissionScheme` PermissionPayloadDTO, nullable — The payload to create a permission scheme
      - `addAddonRole` boolean — Configuration to generate addon role. Default is false if null. Only applies to GLOBAL-scoped permission scheme
      - `description` string — The description of the permission scheme
      - `grants` PermissionGrantDTO[] — List of permission grants
        - `applicationAccess` string[]
        - `groupCustomFields` ProjectCreateResourceIdentifier[]
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `groups` ProjectCreateResourceIdentifier[]
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `permissionKeys` string[]
        - `projectRoles` ProjectCreateResourceIdentifier[]
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `specialGrants` string[]
        - `userCustomFields` ProjectCreateResourceIdentifier[]
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `users` ProjectCreateResourceIdentifier[]
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
      - `name` string — The name of the permission scheme
      - `onConflict` 'FAIL' | 'USE' | 'NEW' — The strategy to use when there is a conflict with an existing permission scheme. FAIL - Fail execution, this always needs to be unique; USE - Use the existing entity and ignore new entity parameters; NEW - If the entity exist, try and create a new one with a different name
      - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
        - `anID` boolean
        - `areference` boolean
        - `entityId` string
        - `entityType` string
        - `id` string
        - `type` 'id' | 'ref'
    - `project` ProjectPayload — The payload for creating a project
      - `fieldLayoutSchemeId` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
        - `anID` boolean
        - `areference` boolean
        - `entityId` string
        - `entityType` string
        - `id` string
        - `type` 'id' | 'ref'
      - `issueSecuritySchemeId` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
        - `anID` boolean
        - `areference` boolean
        - `entityId` string
        - `entityType` string
        - `id` string
        - `type` 'id' | 'ref'
      - `issueTypeSchemeId` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
        - `anID` boolean
        - `areference` boolean
        - `entityId` string
        - `entityType` string
        - `id` string
        - `type` 'id' | 'ref'
      - `issueTypeScreenSchemeId` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
        - `anID` boolean
        - `areference` boolean
        - `entityId` string
        - `entityType` string
        - `id` string
        - `type` 'id' | 'ref'
      - `notificationSchemeId` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
        - `anID` boolean
        - `areference` boolean
        - `entityId` string
        - `entityType` string
        - `id` string
        - `type` 'id' | 'ref'
      - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
        - `anID` boolean
        - `areference` boolean
        - `entityId` string
        - `entityType` string
        - `id` string
        - `type` 'id' | 'ref'
      - `permissionSchemeId` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
        - `anID` boolean
        - `areference` boolean
        - `entityId` string
        - `entityType` string
        - `id` string
        - `type` 'id' | 'ref'
      - `projectTypeKey` 'software' | 'business' | 'service_desk' | 'product_discovery' — The [project type](https://confluence.atlassian.com/x/GwiiLQ#Jiraapplicationsoverview-Productfeaturesandprojecttypes), which defines the application-specific feature set. If you don't specify the project template you have to specify the project type.
      - `workflowSchemeId` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
        - `anID` boolean
        - `areference` boolean
        - `entityId` string
        - `entityType` string
        - `id` string
        - `type` 'id' | 'ref'
    - `role` RolesCapabilityPayload, nullable
      - `roleToProjectActors` object — A map of role PCRI (can be ID or REF) to a list of user or group PCRI IDs to associate with the role and project.
      - `roles` RolePayload[] — The list of roles to create.
        - `defaultActors` ProjectCreateResourceIdentifier[] — The default actors for the role. By adding default actors, the role will be added to any future projects created
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `description` string — The description of the role
        - `name` string — The name of the role
        - `onConflict` 'FAIL' | 'USE' | 'NEW' — The strategy to use when there is a conflict with an existing project role. FAIL - Fail execution, this always needs to be unique; USE - Use the existing entity and ignore new entity parameters
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `type` 'HIDDEN' | 'VIEWABLE' | 'AI_AGENT' | 'EDITABLE' | 'GUEST' — The type of the role. Only used by project-scoped project
    - `scope` ScopePayload, nullable — The payload for creating a scope. Defines if a project is team-managed project or company-managed project
      - `type` 'GLOBAL' | 'PROJECT' — The type of the scope. Use `GLOBAL` or empty for company-managed project, and `PROJECT` for team-managed project
    - `security` SecuritySchemePayload, nullable — The payload for creating a security scheme. See https://support.atlassian.com/jira-cloud-administration/docs/configure-issue-security-schemes/
      - `description` string — The description of the security scheme
      - `name` string — The name of the security scheme
      - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
        - `anID` boolean
        - `areference` boolean
        - `entityId` string
        - `entityType` string
        - `id` string
        - `type` 'id' | 'ref'
      - `securityLevels` SecurityLevelPayload[] — The security levels for the security scheme
        - `description` string — The description of the security level
        - `isDefault` true | false — Whether the security level is default for the security scheme
        - `name` string — The name of the security level
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `securityLevelMembers` SecurityLevelMemberPayload[] — The members of the security level
          - `parameter` string — Defines the value associated with the type. For reporter this would be \{"null"\}; for users this would be the names of specific users); for group this would be group names like \{"administrators", "jira-administrators", "jira-users"\}
          - `type` 'group' | 'reporter' | 'users' — The type of the security level member
    - `workflow` WorkflowCapabilityPayload, nullable — The payload for creating a workflows. See https://www.atlassian.com/software/jira/guides/workflows/overview\#what-is-a-jira-workflow
      - `statuses` StatusPayload[] — The statuses for the workflow
        - `description` string — The description of the status
        - `name` string — The name of the status
        - `onConflict` 'FAIL' | 'USE' | 'NEW' — The conflict strategy for the status already exists. FAIL - Fail execution, this always needs to be unique; USE - Use the existing entity and ignore new entity parameters; NEW - Create a new entity
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `statusCategory` 'TODO' | 'IN_PROGRESS' | 'DONE' — The status category of the status. The value is case-sensitive.
      - `workflowScheme` WorkflowSchemePayload — The payload for creating a workflow scheme. See https://www.atlassian.com/software/jira/guides/workflows/overview\#what-is-a-jira-workflow-scheme
        - `defaultWorkflow` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `description` string — The description of the workflow scheme
        - `explicitMappings` object — Association between issuetypes and workflows
        - `name` string — The name of the workflow scheme
        - `onConflict` 'FAIL' | 'USE' | 'NEW' — The strategy to use if there is a conflict with another workflow scheme
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
      - `workflows` WorkflowPayload[] — The transitions for the workflow
        - `description` string — The description of the workflow
        - `loopedTransitionContainerLayout` WorkflowStatusLayoutPayload — The layout of the workflow status.
          - `x` number, double — The x coordinate of the status.
          - `y` number, double — The y coordinate of the status.
        - `name` string — The name of the workflow
        - `onConflict` 'FAIL' | 'USE' | 'NEW' — The strategy to use if there is a conflict with another workflow
        - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
          - `anID` boolean
          - `areference` boolean
          - `entityId` string
          - `entityType` string
          - `id` string
          - `type` 'id' | 'ref'
        - `startPointLayout` WorkflowStatusLayoutPayload — The layout of the workflow status.
          - `x` number, double — The x coordinate of the status.
          - `y` number, double — The y coordinate of the status.
        - `statuses` WorkflowStatusPayload[] — The statuses to be used in the workflow
          - `layout` WorkflowStatusLayoutPayload — The layout of the workflow status.
            - `x` number, double — The x coordinate of the status.
            - `y` number, double — The y coordinate of the status.
          - `pcri` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
            - `anID` boolean
            - `areference` boolean
            - `entityId` string
            - `entityType` string
            - `id` string
            - `type` 'id' | 'ref'
          - `properties` object — The properties of the workflow status.
        - `transitions` TransitionPayload[] — The transitions for the workflow
          - `actions` RulePayload[] — The actions that are performed when the transition is made
            - `parameters` object — The parameters of the rule
            - `ruleKey` string — The key of the rule. See https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-workflows/\#api-rest-api-3-workflows-capabilities-get
          - `conditions` ConditionGroupPayload — The payload for creating a condition group in a workflow
            - `conditionGroup` ConditionGroupPayload[] — The nested conditions of the condition group.
            - `conditions` RulePayload[] — The rules for this condition.
              - …
            - `operation` 'ANY' | 'ALL' — Determines how the conditions in the group are evaluated. Accepts either `ANY` or `ALL`. If `ANY` is used, at least one condition in the group must be true for the group to evaluate to true. If `ALL` is used, all conditions in the group must be true for the group to evaluate to true.
          - `customIssueEventId` string — Mechanism in Jira for triggering certain actions, like notifications, automations, etc. Unless a custom notification scheme is configure, it's better not to provide any value here
          - `description` string — The description of the transition
          - `from` FromLayoutPayload[] — The statuses that the transition can be made from
            - `fromPort` integer — The port that the transition can be made from
            - `status` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
              - …
            - `toPortOverride` integer — The port that the transition goes to
          - `id` integer — The id of the transition
          - `name` string — The name of the transition
          - `properties` object — The properties of the transition
          - `to` ToLayoutPayload — The payload for the layout details for the destination end of a transition
            - `port` integer — Defines where the transition line will be connected to a status. Port 0 to 7 are acceptable values.
            - `status` ProjectCreateResourceIdentifier — Every project-created entity has an ID that must be unique within the scope of the project creation. PCRI (Project Create Resource Identifier) is a standard format for creating IDs and references to other project entities. PCRI format is defined as follows: pcri:\[entityType\]:\[type\]:\[entityId\] entityType - the type of an entity, e.g. status, role, workflow type - PCRI type, either `id` - The ID of an entity that already exists in the target site, or `ref` - A unique reference to an entity that is being created entityId - entity identifier, if type is `id` - must be an existing entity ID that exists in the Jira site, if `ref` - must be unique across all entities in the scope of this project template creation
              - …
          - `transitionScreen` RulePayload — The payload for creating rules in a workflow
            - `parameters` object — The parameters of the rule
            - `ruleKey` string — The key of the rule. See https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-workflows/\#api-rest-api-3-workflows-capabilities-get
          - `triggers` RulePayload[] — The triggers that are performed when the transition is made
            - `parameters` object — The parameters of the rule
            - `ruleKey` string — The key of the rule. See https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-workflows/\#api-rest-api-3-workflows-capabilities-get
          - `type` 'global' | 'initial' | 'directed' — The type of the transition
          - `validators` RulePayload[] — The validators that are performed when the transition is made
            - `parameters` object — The parameters of the rule
            - `ruleKey` string — The key of the rule. See https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-workflows/\#api-rest-api-3-workflows-capabilities-get

## Other responses

- `303` — The project creation task has been queued for execution

---

[API](https://skmtc.net/atlassian/apis/the-jira-cloud-platform-rest-api-2.md) · [All operations](https://skmtc.net/atlassian/apis/the-jira-cloud-platform-rest-api-2/llms.txt) · [OpenAPI document](https://skmtc-service-staging.skmtc.workers.dev/v1/apis/atlassian/the-jira-cloud-platform-rest-api-2/versions/5a51740d7ab3/schema)