@lap v0.3
# Machine-readable API spec. Each @endpoint block is one API call.
@api The Jira Cloud platform REST API
@base https://your-domain.atlassian.net
@version 1001.0.0-SNAPSHOT-b3b58c01f8925e44dc69b63d90c3ee1d53bec5a6
@auth OAuth2 | Bearer basic
@endpoints 621
@hint download_for_search
@toc rest(621)

@endpoint GET /rest/api/3/announcementBanner
@returns(200) {hashId: str, isDismissible: bool, isEnabled: bool, message: str, visibility: str}
@errors {401, 403}

@endpoint PUT /rest/api/3/announcementBanner
@optional {isDismissible: bool, isEnabled: bool, message: str, visibility: str}
@returns(204)
@errors {400, 401, 403}

@endpoint POST /rest/api/3/app/field/context/configuration/list
@required {fieldIdsOrKeys: [str]}
@optional {id: [int(int64)], fieldContextId: [int(int64)], issueId: int(int64), projectKeyOrId: str, issueTypeId: str, startAt: int(int64)=0, maxResults: int(int32)=100}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/app/field/value
@optional {generateChangelog: bool=true, updates: [map{customField!: str, issueIds!: [int(int64)], value!: any}]}
@returns(204)
@errors {400, 403, 404}

@endpoint GET /rest/api/3/app/field/{fieldIdOrKey}/context/configuration
@required {fieldIdOrKey: str}
@optional {id: [int(int64)], fieldContextId: [int(int64)], issueId: int(int64), projectKeyOrId: str, issueTypeId: str, startAt: int(int64)=0, maxResults: int(int32)=100}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/app/field/{fieldIdOrKey}/context/configuration
@required {fieldIdOrKey: str, configurations: [map{configuration: any, fieldContextId!: str, id!: str, schema: any}]}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/app/field/{fieldIdOrKey}/value
@required {fieldIdOrKey: str}
@optional {generateChangelog: bool=true, updates: [map{issueIds!: [int(int64)], value!: any}]}
@returns(204)
@errors {400, 403, 404}

@endpoint GET /rest/api/3/application-properties
@optional {key: str, permissionLevel: str, keyFilter: str}
@returns(200)
@errors {401, 404}

@endpoint GET /rest/api/3/application-properties/advanced-settings
@returns(200)
@errors {401, 403}

@endpoint PUT /rest/api/3/application-properties/{id}
@required {id: str}
@optional {id: str, value: str}
@returns(200) {allowedValues: [str], defaultValue: str, desc: str, example: str, id: str, key: str, name: str, type: str, value: str}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/applicationrole
@returns(200)
@errors {401, 403}

@endpoint GET /rest/api/3/applicationrole/{key}
@required {key: str}
@returns(200) {defaultGroups: [str], defaultGroupsDetails: [map], defined: bool, groupDetails: [map], groups: [str], hasUnlimitedSeats: bool, key: str, name: str, numberOfSeats: int(int32), platform: bool, remainingSeats: int(int32), selectedByDefault: bool, userCount: int(int32), userCountDescription: str}
@errors {401, 403, 404}

@endpoint GET /rest/api/3/attachment/content/{id}
@required {id: str}
@optional {redirect: bool=true}
@returns(200)
@returns(206)
@errors {303, 400, 401, 403, 404, 416}

@endpoint GET /rest/api/3/attachment/meta
@returns(200) {enabled: bool, uploadLimit: int(int64)}
@errors {401}

@endpoint GET /rest/api/3/attachment/thumbnail/{id}
@required {id: str}
@optional {redirect: bool=true, fallbackToDefault: bool=true, width: int(int32), height: int(int32)}
@returns(200)
@errors {303, 400, 401, 403, 404}

@endpoint DELETE /rest/api/3/attachment/{id}
@required {id: str}
@returns(204)
@errors {403, 404}

@endpoint GET /rest/api/3/attachment/{id}
@required {id: str}
@returns(200) {author: any, content: str, created: str(date-time), filename: str, id: int(int64), mimeType: str, properties: map, self: str(uri), size: int(int64), thumbnail: str}
@errors {401, 403, 404}

@endpoint GET /rest/api/3/attachment/{id}/expand/human
@required {id: str}
@returns(200) {entries: [map], id: int(int64), mediaType: str, name: str, totalEntryCount: int(int64)}
@errors {401, 403, 404, 409}

@endpoint GET /rest/api/3/attachment/{id}/expand/raw
@required {id: str}
@returns(200) {entries: [map], totalEntryCount: int(int32)}
@errors {401, 403, 404, 409}

@endpoint GET /rest/api/3/auditing/record
@optional {offset: int(int32)=0, limit: int(int32)=1000, filter: str, from: str, to: str}
@returns(200) {limit: int(int32), offset: int(int32), records: [map], total: int(int64)}
@errors {401, 403}

@endpoint GET /rest/api/3/avatar/{type}/system
@required {type: str(issuetype/project/user/priority)}
@returns(200) {system: [map]}
@errors {401, 500}

@endpoint POST /rest/api/3/bulk/issues/delete
@required {selectedIssueIdsOrKeys: [str]}
@optional {sendBulkNotification: bool=true}
@returns(201) {taskId: str}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/bulk/issues/fields
@required {issueIdsOrKeys: str}
@optional {searchText: str, endingBefore: str, startingAfter: str}
@returns(200) {endingBefore: str, fields: [map], startingAfter: str}
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/bulk/issues/fields
@required {editedFieldsInput: any, selectedActions: [str], selectedIssueIdsOrKeys: [str]}
@optional {sendBulkNotification: bool=true}
@returns(201) {taskId: str}
@errors {400, 401}

@endpoint POST /rest/api/3/bulk/issues/move
@optional {sendBulkNotification: bool=true, targetToSourcesMapping: map}
@returns(201) {taskId: str}
@errors {400, 401}

@endpoint GET /rest/api/3/bulk/issues/transition
@required {issueIdsOrKeys: str}
@optional {endingBefore: str, startingAfter: str}
@returns(200) {availableTransitions: [map], endingBefore: str, startingAfter: str}
@errors {400, 401, 403}

@endpoint POST /rest/api/3/bulk/issues/transition
@required {bulkTransitionInputs: [map{selectedIssueIdsOrKeys!: [str], transitionId!: str}]}
@optional {sendBulkNotification: bool=true}
@returns(201) {taskId: str}
@errors {400, 401, 403}

@endpoint POST /rest/api/3/bulk/issues/unwatch
@required {selectedIssueIdsOrKeys: [str]}
@returns(201) {taskId: str}
@errors {400, 401, 403}

@endpoint POST /rest/api/3/bulk/issues/watch
@required {selectedIssueIdsOrKeys: [str]}
@returns(201) {taskId: str}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/bulk/queue/{taskId}
@required {taskId: str}
@returns(200) {created: str(date-time), failedAccessibleIssues: map, invalidOrInaccessibleIssueCount: int(int32), processedAccessibleIssues: [int(int64)], progressPercent: int(int64), started: str(date-time), status: str, submittedBy: map{accountId: str, accountType: str, active: bool, appType: str, applicationRoles: any, avatarUrls: any, displayName: str, emailAddress: str, expand: str, groups: any, guest: bool, key: str, locale: str, name: str, self: str(uri), timeZone: str}, taskId: str, totalIssueCount: int(int32), updated: str(date-time)}
@errors {400, 401}

@endpoint POST /rest/api/3/changelog/bulkfetch
@required {issueIdsOrKeys: [str]}
@optional {fieldIds: [str], maxResults: int(int32)=1000, nextPageToken: str}
@returns(200) {issueChangeLogs: [map], nextPageToken: str}
@errors {400}

@endpoint GET /rest/api/3/classification-levels
@optional {status: [str], orderBy: str(rank/-rank/+rank)}
@returns(200) {classifications: [map]}
@errors {401}

@endpoint POST /rest/api/3/comment/list
@required {ids: [int(int64)]}
@optional {expand: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400}

@endpoint GET /rest/api/3/comment/{commentId}/properties
@required {commentId: str}
@returns(200) {keys: [map]}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/comment/{commentId}/properties/{propertyKey}
@required {commentId: str, propertyKey: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/comment/{commentId}/properties/{propertyKey}
@required {commentId: str, propertyKey: str}
@returns(200) {key: str, value: any}
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/comment/{commentId}/properties/{propertyKey}
@required {commentId: str, propertyKey: str}
@returns(200)
@returns(201)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/component
@optional {projectIdsOrKeys: [str], startAt: int(int64)=0, maxResults: int(int32)=50, orderBy: str(description/-description/+description/name/-name/+name), query: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 404}

@endpoint POST /rest/api/3/component
@optional {ari: str, assignee: any, assigneeType: str(PROJECT_DEFAULT/COMPONENT_LEAD/PROJECT_LEAD/UNASSIGNED), description: str, id: str, isAssigneeTypeValid: bool, lead: any, leadAccountId: str, leadUserName: str, metadata: map, name: str, project: str, projectId: int(int64), realAssignee: any, realAssigneeType: str(PROJECT_DEFAULT/COMPONENT_LEAD/PROJECT_LEAD/UNASSIGNED), self: str(uri)}
@returns(201) {ari: str, assignee: any, assigneeType: str, description: str, id: str, isAssigneeTypeValid: bool, lead: any, leadAccountId: str, leadUserName: str, metadata: map, name: str, project: str, projectId: int(int64), realAssignee: any, realAssigneeType: str, self: str(uri)}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/component/{id}
@required {id: str}
@optional {moveIssuesTo: str}
@returns(204)
@errors {401, 403, 404}

@endpoint GET /rest/api/3/component/{id}
@required {id: str}
@returns(200) {ari: str, assignee: any, assigneeType: str, description: str, id: str, isAssigneeTypeValid: bool, lead: any, leadAccountId: str, leadUserName: str, metadata: map, name: str, project: str, projectId: int(int64), realAssignee: any, realAssigneeType: str, self: str(uri)}
@errors {401, 404}

@endpoint PUT /rest/api/3/component/{id}
@required {id: str}
@optional {ari: str, assignee: any, assigneeType: str(PROJECT_DEFAULT/COMPONENT_LEAD/PROJECT_LEAD/UNASSIGNED), description: str, id: str, isAssigneeTypeValid: bool, lead: any, leadAccountId: str, leadUserName: str, metadata: map, name: str, project: str, projectId: int(int64), realAssignee: any, realAssigneeType: str(PROJECT_DEFAULT/COMPONENT_LEAD/PROJECT_LEAD/UNASSIGNED), self: str(uri)}
@returns(200) {ari: str, assignee: any, assigneeType: str, description: str, id: str, isAssigneeTypeValid: bool, lead: any, leadAccountId: str, leadUserName: str, metadata: map, name: str, project: str, projectId: int(int64), realAssignee: any, realAssigneeType: str, self: str(uri)}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/component/{id}/relatedIssueCounts
@required {id: str}
@returns(200) {issueCount: int(int64), self: str(uri)}
@errors {401, 404}

@endpoint GET /rest/api/3/config/fieldschemes
@optional {projectId: [int(int64)], query: str, startAt: int(int64)=0, maxResults: int(int32)=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/config/fieldschemes
@required {name: str}
@optional {description: str}
@returns(200) {description: str, id: int(int64), links: map{associations: str, projects: str}, name: str}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/config/fieldschemes/fields
@returns(200) {results: [map]}
@returns(204)
@returns(207) {results: [map]}
@errors {400, 401, 403}

@endpoint PUT /rest/api/3/config/fieldschemes/fields
@returns(200) {results: [map]}
@returns(204)
@returns(207) {results: [map]}
@errors {400, 401, 403}

@endpoint DELETE /rest/api/3/config/fieldschemes/fields/parameters
@returns(200)
@returns(204)
@returns(207) {results: [map]}
@errors {400, 401, 403}

@endpoint PUT /rest/api/3/config/fieldschemes/fields/parameters
@returns(200) {results: [map]}
@returns(204)
@returns(207) {results: [map]}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/config/fieldschemes/projects
@required {projectId: [int(int64)]}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/config/fieldschemes/projects
@returns(200) {results: [map]}
@returns(204)
@returns(207) {results: [map]}
@errors {400, 401, 403}

@endpoint DELETE /rest/api/3/config/fieldschemes/{id}
@required {id: int(int64)}
@returns(200) {deleted: bool, id: str}
@errors {400, 401, 403, 404, 409}

@endpoint GET /rest/api/3/config/fieldschemes/{id}
@required {id: int(int64)}
@returns(200) {description: str, id: str, isDefault: bool, links: map{associations: str, projects: str}, name: str}
@errors {403, 404}

@endpoint PUT /rest/api/3/config/fieldschemes/{id}
@required {id: int(int64)}
@optional {description: str, name: str}
@returns(200) {description: str, id: int(int64), links: map{associations: str, projects: str}, name: str}
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/config/fieldschemes/{id}/clone
@required {id: int(int64), name: str}
@optional {description: str}
@returns(200) {description: str, id: int(int64), links: map{associations: str, projects: str}, name: str}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/config/fieldschemes/{id}/fields
@required {id: int(int64)}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, fieldId: [str]}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/config/fieldschemes/{id}/fields/{fieldId}/parameters
@required {id: int(int64), fieldId: str}
@returns(200) {fieldId: str, parameters: map{description: str, isRequired: bool}, workTypeParameters: [map]}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/config/fieldschemes/{id}/projects
@required {id: int(int64)}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, projectId: [int(int64)]}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/configuration
@returns(200) {attachmentsEnabled: bool, issueLinkingEnabled: bool, subTasksEnabled: bool, timeTrackingConfiguration: any, timeTrackingEnabled: bool, unassignedIssuesAllowed: bool, votingEnabled: bool, watchingEnabled: bool}
@errors {401}

@endpoint GET /rest/api/3/configuration/timetracking
@returns(200) {key: str, name: str, url: str}
@returns(204)
@errors {401, 403}

@endpoint PUT /rest/api/3/configuration/timetracking
@required {key: str}
@optional {name: str, url: str}
@returns(204)
@errors {400, 401, 403}

@endpoint GET /rest/api/3/configuration/timetracking/list
@returns(200)
@errors {401, 403}

@endpoint GET /rest/api/3/configuration/timetracking/options
@returns(200) {defaultUnit: str, timeFormat: str, workingDaysPerWeek: num(double), workingHoursPerDay: num(double)}
@errors {401, 403}

@endpoint PUT /rest/api/3/configuration/timetracking/options
@required {defaultUnit: str(minute/hour/day/week), timeFormat: str(pretty/days/hours), workingDaysPerWeek: num(double), workingHoursPerDay: num(double)}
@returns(200) {defaultUnit: str, timeFormat: str, workingDaysPerWeek: num(double), workingHoursPerDay: num(double)}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/customFieldOption/{id}
@required {id: str}
@returns(200) {self: str(uri), value: str}
@errors {401, 404}

@endpoint GET /rest/api/3/dashboard
@optional {filter: str(my/favourite), startAt: int(int32)=0, maxResults: int(int32)=20}
@returns(200) {dashboards: [map], maxResults: int(int32), next: str, prev: str, startAt: int(int32), total: int(int32)}
@errors {400, 401}

@endpoint POST /rest/api/3/dashboard
@required {editPermissions: [map{group: any, id: int(int64), project: any, role: any, type!: str, user: any}], name: str, sharePermissions: [map{group: any, id: int(int64), project: any, role: any, type!: str, user: any}]}
@optional {extendAdminPermissions: bool=false, description: str}
@returns(200) {automaticRefreshMs: int(int32), description: str, editPermissions: [map], id: str, isFavourite: bool, isWritable: bool, name: str, owner: any, popularity: int(int64), rank: int(int32), self: str(uri), sharePermissions: [map], systemDashboard: bool, view: str}
@errors {400, 401}

@endpoint PUT /rest/api/3/dashboard/bulk/edit
@required {action: str(changeOwner/changePermission/addPermission/removePermission), entityIds: [int(int64)]}
@optional {changeOwnerDetails: any, extendAdminPermissions: bool, permissionDetails: any}
@returns(200) {action: str, entityErrors: map}
@errors {400, 401}

@endpoint GET /rest/api/3/dashboard/gadgets
@returns(200) {gadgets: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/dashboard/search
@optional {dashboardName: str, accountId: str, owner: str, groupname: str, groupId: str, projectId: int(int64), orderBy: str(description/-description/+description/favorite_count/-favorite_count/+favorite_count/id/-id/+id/is_favorite/-is_favorite/+is_favorite/name/-name/+name/owner/-owner/+owner)=name, startAt: int(int64)=0, maxResults: int(int32)=50, status: str(active/archived/deleted)=active, expand: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/dashboard/{dashboardId}/gadget
@required {dashboardId: int(int64)}
@optional {moduleKey: [str], uri: [str], gadgetId: [int(int64)]}
@returns(200) {gadgets: [map]}
@errors {401, 404}

@endpoint POST /rest/api/3/dashboard/{dashboardId}/gadget
@required {dashboardId: int(int64)}
@optional {color: str, ignoreUriAndModuleKeyValidation: bool, moduleKey: str, position: any, title: str, uri: str}
@returns(200) {color: str, id: int(int64), moduleKey: str, position: any, title: str, uri: str}
@errors {400, 401, 404}

@endpoint DELETE /rest/api/3/dashboard/{dashboardId}/gadget/{gadgetId}
@required {dashboardId: int(int64), gadgetId: int(int64)}
@returns(204)
@errors {401, 404}

@endpoint PUT /rest/api/3/dashboard/{dashboardId}/gadget/{gadgetId}
@required {dashboardId: int(int64), gadgetId: int(int64)}
@optional {color: str, position: any, title: str}
@returns(204)
@errors {400, 401, 404}

@endpoint GET /rest/api/3/dashboard/{dashboardId}/items/{itemId}/properties
@required {dashboardId: str, itemId: str}
@returns(200) {keys: [map]}
@errors {401, 404}

@endpoint DELETE /rest/api/3/dashboard/{dashboardId}/items/{itemId}/properties/{propertyKey}
@required {dashboardId: str, itemId: str, propertyKey: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/dashboard/{dashboardId}/items/{itemId}/properties/{propertyKey}
@required {dashboardId: str, itemId: str, propertyKey: str}
@returns(200) {key: str, value: any}
@errors {401, 404}

@endpoint PUT /rest/api/3/dashboard/{dashboardId}/items/{itemId}/properties/{propertyKey}
@required {dashboardId: str, itemId: str, propertyKey: str}
@returns(200)
@returns(201)
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/dashboard/{id}
@required {id: str}
@returns(204)
@errors {400, 401}

@endpoint GET /rest/api/3/dashboard/{id}
@required {id: str}
@returns(200) {automaticRefreshMs: int(int32), description: str, editPermissions: [map], id: str, isFavourite: bool, isWritable: bool, name: str, owner: any, popularity: int(int64), rank: int(int32), self: str(uri), sharePermissions: [map], systemDashboard: bool, view: str}
@errors {400, 401, 404}

@endpoint PUT /rest/api/3/dashboard/{id}
@required {id: str, editPermissions: [map{group: any, id: int(int64), project: any, role: any, type!: str, user: any}], name: str, sharePermissions: [map{group: any, id: int(int64), project: any, role: any, type!: str, user: any}]}
@optional {extendAdminPermissions: bool=false, description: str}
@returns(200) {automaticRefreshMs: int(int32), description: str, editPermissions: [map], id: str, isFavourite: bool, isWritable: bool, name: str, owner: any, popularity: int(int64), rank: int(int32), self: str(uri), sharePermissions: [map], systemDashboard: bool, view: str}
@errors {400, 401, 404}

@endpoint POST /rest/api/3/dashboard/{id}/copy
@required {id: str, editPermissions: [map{group: any, id: int(int64), project: any, role: any, type!: str, user: any}], name: str, sharePermissions: [map{group: any, id: int(int64), project: any, role: any, type!: str, user: any}]}
@optional {extendAdminPermissions: bool=false, description: str}
@returns(200) {automaticRefreshMs: int(int32), description: str, editPermissions: [map], id: str, isFavourite: bool, isWritable: bool, name: str, owner: any, popularity: int(int64), rank: int(int32), self: str(uri), sharePermissions: [map], systemDashboard: bool, view: str}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/data-policy
@returns(200) {anyContentBlocked: bool}
@errors {401, 403}

@endpoint GET /rest/api/3/data-policy/project
@optional {ids: str}
@returns(200) {projectDataPolicies: [map]}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/events
@returns(200)
@errors {401, 403}

@endpoint POST /rest/api/3/expression/analyse
@required {expressions: [str]}
@optional {check: str(syntax/type/complexity)=syntax, contextVariables: map}
@returns(200) {results: [map]}
@errors {400, 401, 404}

@endpoint POST /rest/api/3/expression/eval
@required {expression: str}
@optional {expand: str, context: any}
@returns(200) {meta: any, value: any}
@errors {400, 401, 404}

@endpoint POST /rest/api/3/expression/evaluate
@required {expression: str}
@optional {expand: str, context: any}
@returns(200) {meta: any, value: any}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/field
@returns(200)
@errors {401}

@endpoint POST /rest/api/3/field
@required {name: str, type: str}
@optional {description: str, searcherKey: str(com.atlassian.jira.plugin.system.customfieldtypes:cascadingselectsearcher/com.atlassian.jira.plugin.system.customfieldtypes:daterange/com.atlassian.jira.plugin.system.customfieldtypes:datetimerange/com.atlassian.jira.plugin.system.customfieldtypes:exactnumber/com.atlassian.jira.plugin.system.customfieldtypes:exacttextsearcher/com.atlassian.jira.plugin.system.customfieldtypes:grouppickersearcher/com.atlassian.jira.plugin.system.customfieldtypes:labelsearcher/com.atlassian.jira.plugin.system.customfieldtypes:multiselectsearcher/com.atlassian.jira.plugin.system.customfieldtypes:numberrange/com.atlassian.jira.plugin.system.customfieldtypes:projectsearcher/com.atlassian.jira.plugin.system.customfieldtypes:textsearcher/com.atlassian.jira.plugin.system.customfieldtypes:userpickergroupsearcher/com.atlassian.jira.plugin.system.customfieldtypes:versionsearcher)}
@returns(201) {clauseNames: [str], custom: bool, id: str, key: str, name: str, navigable: bool, orderable: bool, schema: any, scope: any, searchable: bool}
@errors {400}

@endpoint DELETE /rest/api/3/field/association
@required {associationContexts: [map{identifier: map, type!: str}], fields: [map{identifier: map, type!: str}]}
@returns(204)
@errors {400, 401, 404}

@endpoint PUT /rest/api/3/field/association
@required {associationContexts: [map{identifier: map, type!: str}], fields: [map{identifier: map, type!: str}]}
@returns(204)
@errors {400, 401, 404}

@endpoint GET /rest/api/3/field/search
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, type: [str], id: [str], query: str, orderBy: str(contextsCount/-contextsCount/+contextsCount/lastUsed/-lastUsed/+lastUsed/name/-name/+name/screensCount/-screensCount/+screensCount/projectsCount/-projectsCount/+projectsCount), expand: str, projectIds: [int(int64)]}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/field/search/trashed
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, id: [str], query: str, expand: str(name/-name/+name/trashDate/-trashDate/+trashDate/plannedDeletionDate/-plannedDeletionDate/+plannedDeletionDate/projectsCount/-projectsCount/+projectsCount), orderBy: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint PUT /rest/api/3/field/{fieldId}
@required {fieldId: str}
@optional {description: str, name: str, searcherKey: str(com.atlassian.jira.plugin.system.customfieldtypes:cascadingselectsearcher/com.atlassian.jira.plugin.system.customfieldtypes:daterange/com.atlassian.jira.plugin.system.customfieldtypes:datetimerange/com.atlassian.jira.plugin.system.customfieldtypes:exactnumber/com.atlassian.jira.plugin.system.customfieldtypes:exacttextsearcher/com.atlassian.jira.plugin.system.customfieldtypes:grouppickersearcher/com.atlassian.jira.plugin.system.customfieldtypes:labelsearcher/com.atlassian.jira.plugin.system.customfieldtypes:multiselectsearcher/com.atlassian.jira.plugin.system.customfieldtypes:numberrange/com.atlassian.jira.plugin.system.customfieldtypes:projectsearcher/com.atlassian.jira.plugin.system.customfieldtypes:textsearcher/com.atlassian.jira.plugin.system.customfieldtypes:userpickergroupsearcher/com.atlassian.jira.plugin.system.customfieldtypes:versionsearcher)}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/field/{fieldId}/association/project
@required {fieldId: str}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/field/{fieldId}/context
@required {fieldId: str}
@optional {isAnyIssueType: bool, isGlobalContext: bool, contextId: [int(int64)], startAt: int(int64)=0, maxResults: int(int32)=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 403, 404}

@endpoint POST /rest/api/3/field/{fieldId}/context
@required {fieldId: str, name: str}
@optional {description: str, id: str, issueTypeIds: [str], projectIds: [str]}
@returns(201) {description: str, id: str, issueTypeIds: [str], name: str, projectIds: [str]}
@errors {400, 401, 404, 409}

@endpoint GET /rest/api/3/field/{fieldId}/context/defaultValue
@required {fieldId: str}
@optional {contextId: [int(int64)], startAt: int(int64)=0, maxResults: int(int32)=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/field/{fieldId}/context/defaultValue
@required {fieldId: str}
@optional {defaultValues: [map]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/field/{fieldId}/context/issuetypemapping
@required {fieldId: str}
@optional {contextId: [int(int64)], startAt: int(int64)=0, maxResults: int(int32)=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 403}

@endpoint POST /rest/api/3/field/{fieldId}/context/mapping
@required {fieldId: str, mappings: [map{issueTypeId!: str, projectId!: str}]}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/field/{fieldId}/context/projectmapping
@required {fieldId: str}
@optional {contextId: [int(int64)], startAt: int(int64)=0, maxResults: int(int32)=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 403, 404}

@endpoint DELETE /rest/api/3/field/{fieldId}/context/{contextId}
@required {fieldId: str, contextId: int(int64)}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/field/{fieldId}/context/{contextId}
@required {fieldId: str, contextId: int(int64)}
@optional {description: str, name: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/field/{fieldId}/context/{contextId}/issuetype
@required {fieldId: str, contextId: int(int64), issueTypeIds: [str]}
@returns(204)
@errors {400, 401, 403, 404, 409}

@endpoint POST /rest/api/3/field/{fieldId}/context/{contextId}/issuetype/remove
@required {fieldId: str, contextId: int(int64), issueTypeIds: [str]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/field/{fieldId}/context/{contextId}/option
@required {fieldId: str, contextId: int(int64)}
@optional {optionId: int(int64), onlyOptions: bool=false, startAt: int(int64)=0, maxResults: int(int32)=100}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/field/{fieldId}/context/{contextId}/option
@required {fieldId: str, contextId: int(int64)}
@optional {options: [map{disabled: bool, optionId: str, value!: str}]}
@returns(200) {options: [map]}
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/field/{fieldId}/context/{contextId}/option
@required {fieldId: str, contextId: int(int64)}
@optional {options: [map{disabled: bool, id!: str, value: str}]}
@returns(200) {options: [map]}
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/field/{fieldId}/context/{contextId}/option/move
@required {fieldId: str, contextId: int(int64), customFieldOptionIds: [str]}
@optional {after: str, position: str(First/Last)}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/field/{fieldId}/context/{contextId}/option/{optionId}
@required {fieldId: str, contextId: int(int64), optionId: int(int64)}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/field/{fieldId}/context/{contextId}/option/{optionId}/issue
@required {fieldId: str, optionId: int(int64), contextId: int(int64)}
@optional {replaceWith: int(int64), jql: str}
@errors {303, 400, 403, 404}

@endpoint PUT /rest/api/3/field/{fieldId}/context/{contextId}/project
@required {fieldId: str, contextId: int(int64), projectIds: [str]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/field/{fieldId}/context/{contextId}/project/remove
@required {fieldId: str, contextId: int(int64), projectIds: [str]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/field/{fieldId}/contexts
@required {fieldId: str}
@optional {startAt: int(int64)=0, maxResults: int(int32)=20}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 403}

@endpoint GET /rest/api/3/field/{fieldId}/screens
@required {fieldId: str}
@optional {startAt: int(int64)=0, maxResults: int(int32)=100, expand: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 403}

@endpoint GET /rest/api/3/field/{fieldKey}/option
@required {fieldKey: str}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 403}

@endpoint POST /rest/api/3/field/{fieldKey}/option
@required {fieldKey: str, value: str}
@optional {config: map{attributes: [str], scope: any}, properties: map}
@returns(200) {config: map{attributes: [str], scope: any}, id: int(int64), properties: map, value: str}
@errors {400, 403, 404}

@endpoint GET /rest/api/3/field/{fieldKey}/option/suggestions/edit
@required {fieldKey: str}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, projectId: int(int64)}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 404}

@endpoint GET /rest/api/3/field/{fieldKey}/option/suggestions/search
@required {fieldKey: str}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, projectId: int(int64)}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 404}

@endpoint DELETE /rest/api/3/field/{fieldKey}/option/{optionId}
@required {fieldKey: str, optionId: int(int64)}
@returns(204)
@errors {403, 404, 409}

@endpoint GET /rest/api/3/field/{fieldKey}/option/{optionId}
@required {fieldKey: str, optionId: int(int64)}
@returns(200) {config: map{attributes: [str], scope: any}, id: int(int64), properties: map, value: str}
@errors {400, 403, 404}

@endpoint PUT /rest/api/3/field/{fieldKey}/option/{optionId}
@required {fieldKey: str, optionId: int(int64), id: int(int64), value: str}
@optional {config: map{attributes: [str], scope: any}, properties: map}
@returns(200) {config: map{attributes: [str], scope: any}, id: int(int64), properties: map, value: str}
@errors {400, 403, 404}

@endpoint DELETE /rest/api/3/field/{fieldKey}/option/{optionId}/issue
@required {fieldKey: str, optionId: int(int64)}
@optional {replaceWith: int(int64), jql: str, overrideScreenSecurity: bool=false, overrideEditableFlag: bool=false}
@errors {303, 400, 403, 404}

@endpoint DELETE /rest/api/3/field/{id}
@required {id: str}
@errors {303, 400, 401, 403, 404, 409}

@endpoint POST /rest/api/3/field/{id}/restore
@required {id: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/field/{id}/trash
@required {id: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/fieldconfiguration
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, id: [int(int64)], isDefault: bool=false, query: str=}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 403}

@endpoint POST /rest/api/3/fieldconfiguration
@required {name: str}
@optional {description: str}
@returns(200) {description: str, id: int(int64), isDefault: bool, name: str}
@errors {400, 401, 403}

@endpoint DELETE /rest/api/3/fieldconfiguration/{id}
@required {id: int(int64)}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/fieldconfiguration/{id}
@required {id: int(int64), name: str}
@optional {description: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/fieldconfiguration/{id}/fields
@required {id: int(int64)}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/fieldconfiguration/{id}/fields
@required {id: int(int64), fieldConfigurationItems: [map{description: str, id!: str, isHidden: bool, isRequired: bool, renderer: str}]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/fieldconfigurationscheme
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, id: [int(int64)]}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint POST /rest/api/3/fieldconfigurationscheme
@required {name: str}
@optional {description: str}
@returns(201) {description: str, id: str, name: str}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/fieldconfigurationscheme/mapping
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, fieldConfigurationSchemeId: [int(int64)]}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/fieldconfigurationscheme/project
@required {projectId: [int(int64)]}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint PUT /rest/api/3/fieldconfigurationscheme/project
@required {projectId: str}
@optional {fieldConfigurationSchemeId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/fieldconfigurationscheme/{id}
@required {id: int(int64)}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/fieldconfigurationscheme/{id}
@required {id: int(int64), name: str}
@optional {description: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/fieldconfigurationscheme/{id}/mapping
@required {id: int(int64), mappings: [map{fieldConfigurationId!: str, issueTypeId!: str}]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/fieldconfigurationscheme/{id}/mapping/delete
@required {id: int(int64), issueTypeIds: [str]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/filter
@required {name: str}
@optional {expand: str, overrideSharePermissions: bool=false, approximateLastUsed: str(date-time), description: str, editPermissions: [map{group: any, id: int(int64), project: any, role: any, type!: str, user: any}], favourite: bool, favouritedCount: int(int64), id: str, jql: str, owner: any, searchUrl: str(uri), self: str(uri), sharePermissions: [map{group: any, id: int(int64), project: any, role: any, type!: str, user: any}], sharedUsers: any, subscriptions: any, viewUrl: str(uri)}
@returns(200) {approximateLastUsed: str(date-time), description: str, editPermissions: [map], favourite: bool, favouritedCount: int(int64), id: str, jql: str, name: str, owner: any, searchUrl: str(uri), self: str(uri), sharePermissions: [map], sharedUsers: any, subscriptions: any, viewUrl: str(uri)}
@errors {400, 401}

@endpoint GET /rest/api/3/filter/defaultShareScope
@returns(200) {scope: str}
@errors {401}

@endpoint PUT /rest/api/3/filter/defaultShareScope
@required {scope: str(GLOBAL/AUTHENTICATED/PRIVATE)}
@returns(200) {scope: str}
@errors {400, 401}

@endpoint GET /rest/api/3/filter/favourite
@optional {expand: str}
@returns(200)
@errors {401}

@endpoint GET /rest/api/3/filter/my
@optional {expand: str, includeFavourites: bool=false}
@returns(200)
@errors {401}

@endpoint GET /rest/api/3/filter/search
@optional {filterName: str, accountId: str, owner: str, groupname: str, groupId: str, projectId: int(int64), id: [int(int64)], orderBy: str(description/-description/+description/favourite_count/-favourite_count/+favourite_count/id/-id/+id/is_favourite/-is_favourite/+is_favourite/name/-name/+name/owner/-owner/+owner/is_shared/-is_shared/+is_shared)=name, startAt: int(int64)=0, maxResults: int(int32)=50, expand: str, overrideSharePermissions: bool=false, isSubstringMatch: bool=false}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401}

@endpoint DELETE /rest/api/3/filter/{id}
@required {id: int(int64)}
@returns(204)
@errors {400, 401}

@endpoint GET /rest/api/3/filter/{id}
@required {id: int(int64)}
@optional {expand: str, overrideSharePermissions: bool=false}
@returns(200) {approximateLastUsed: str(date-time), description: str, editPermissions: [map], favourite: bool, favouritedCount: int(int64), id: str, jql: str, name: str, owner: any, searchUrl: str(uri), self: str(uri), sharePermissions: [map], sharedUsers: any, subscriptions: any, viewUrl: str(uri)}
@errors {400, 401}

@endpoint PUT /rest/api/3/filter/{id}
@required {id: int(int64), name: str}
@optional {expand: str, overrideSharePermissions: bool=false, approximateLastUsed: str(date-time), description: str, editPermissions: [map{group: any, id: int(int64), project: any, role: any, type!: str, user: any}], favourite: bool, favouritedCount: int(int64), id: str, jql: str, owner: any, searchUrl: str(uri), self: str(uri), sharePermissions: [map{group: any, id: int(int64), project: any, role: any, type!: str, user: any}], sharedUsers: any, subscriptions: any, viewUrl: str(uri)}
@returns(200) {approximateLastUsed: str(date-time), description: str, editPermissions: [map], favourite: bool, favouritedCount: int(int64), id: str, jql: str, name: str, owner: any, searchUrl: str(uri), self: str(uri), sharePermissions: [map], sharedUsers: any, subscriptions: any, viewUrl: str(uri)}
@errors {400, 401}

@endpoint DELETE /rest/api/3/filter/{id}/columns
@required {id: int(int64)}
@returns(204)
@errors {400, 401}

@endpoint GET /rest/api/3/filter/{id}/columns
@required {id: int(int64)}
@returns(200)
@errors {400, 401, 404}

@endpoint PUT /rest/api/3/filter/{id}/columns
@required {id: int(int64)}
@optional {columns: [str]}
@returns(200)
@errors {400, 403}

@endpoint DELETE /rest/api/3/filter/{id}/favourite
@required {id: int(int64)}
@optional {expand: str}
@returns(200) {approximateLastUsed: str(date-time), description: str, editPermissions: [map], favourite: bool, favouritedCount: int(int64), id: str, jql: str, name: str, owner: any, searchUrl: str(uri), self: str(uri), sharePermissions: [map], sharedUsers: any, subscriptions: any, viewUrl: str(uri)}
@errors {400}

@endpoint PUT /rest/api/3/filter/{id}/favourite
@required {id: int(int64)}
@optional {expand: str}
@returns(200) {approximateLastUsed: str(date-time), description: str, editPermissions: [map], favourite: bool, favouritedCount: int(int64), id: str, jql: str, name: str, owner: any, searchUrl: str(uri), self: str(uri), sharePermissions: [map], sharedUsers: any, subscriptions: any, viewUrl: str(uri)}
@errors {400}

@endpoint PUT /rest/api/3/filter/{id}/owner
@required {id: int(int64), accountId: str}
@returns(204)
@errors {400, 403, 404}

@endpoint GET /rest/api/3/filter/{id}/permission
@required {id: int(int64)}
@returns(200)
@errors {401, 404}

@endpoint POST /rest/api/3/filter/{id}/permission
@required {id: int(int64), type: str(user/project/group/projectRole/global/authenticated)}
@optional {accountId: str, groupId: str, groupname: str, projectId: str, projectRoleId: str, rights: int(int32)}
@returns(201)
@errors {400, 401, 404}

@endpoint DELETE /rest/api/3/filter/{id}/permission/{permissionId}
@required {id: int(int64), permissionId: int(int64)}
@returns(204)
@errors {401, 404}

@endpoint GET /rest/api/3/filter/{id}/permission/{permissionId}
@required {id: int(int64), permissionId: int(int64)}
@returns(200) {group: any, id: int(int64), project: any, role: any, type: str, user: any}
@errors {401, 404}

@endpoint POST /rest/api/3/forge/panel/action/bulk/async
@required {moduleId: str, projectList: [map{action!: str, projectIdOrKey!: str}]}
@returns(202) {taskId: str}
@errors {400, 403, 500}

@endpoint DELETE /rest/api/3/group
@optional {groupname: str, groupId: str, swapGroup: str, swapGroupId: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/group
@optional {groupname: str, groupId: str, expand: str}
@returns(200) {expand: str, groupId: str?, name: str, self: str(uri), users: any}
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/group
@required {name: str}
@returns(201) {expand: str, groupId: str?, name: str, self: str(uri), users: any}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/group/bulk
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, groupId: [str], groupName: [str], accessType: str, applicationKey: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 500}

@endpoint GET /rest/api/3/group/member
@optional {groupname: str, groupId: str, includeInactiveUsers: bool=false, startAt: int(int64)=0, maxResults: int(int32)=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/group/user
@required {accountId: str}
@optional {groupname: str, groupId: str, username: str}
@returns(200)
@errors {400, 401, 403, 404, 429}

@endpoint POST /rest/api/3/group/user
@optional {groupname: str, groupId: str, accountId: str, name: str}
@returns(201) {expand: str, groupId: str?, name: str, self: str(uri), users: any}
@errors {400, 401, 403, 404, 429}

@endpoint GET /rest/api/3/groups/picker
@optional {accountId: str, query: str, exclude: [str], excludeId: [str], maxResults: int(int32), caseInsensitive: bool=false, userName: str}
@returns(200) {groups: [map], header: str, total: int(int32)}

@endpoint GET /rest/api/3/groupuserpicker
@required {query: str}
@optional {maxResults: int(int32)=50, showAvatar: bool=false, fieldId: str, projectId: [str], issueTypeId: [str], avatarSize: str(xsmall/xsmall@2x/xsmall@3x/small/small@2x/small@3x/medium/medium@2x/medium@3x/large/large@2x/large@3x/xlarge/xlarge@2x/xlarge@3x/xxlarge/xxlarge@2x/xxlarge@3x/xxxlarge/xxxlarge@2x/xxxlarge@3x)=xsmall, caseInsensitive: bool=false, excludeConnectAddons: bool=false}
@returns(200) {groups: map{groups: [map], header: str, total: int(int32)}, users: map{header: str, total: int(int32), users: [map]}}
@errors {400, 401, 403, 429}

@endpoint GET /rest/api/3/instance/license
@returns(200) {applications: [map]}
@errors {401}

@endpoint POST /rest/api/3/issue
@optional {updateHistory: bool=false, fields: map, historyMetadata: any, properties: [map{key: str, value: any}], transition: any, update: map}
@returns(201) {id: str, key: str, self: str, transition: any, watchers: any}
@errors {400, 401, 403, 422}

@endpoint POST /rest/api/3/issue/archive
@optional {jql: str}
@returns(202)
@errors {400, 401, 403, 412}

@endpoint PUT /rest/api/3/issue/archive
@optional {issueIdsOrKeys: [str]}
@returns(200) {errors: map{issueIsSubtask: map{count: int(int64), issueIdsOrKeys: [str], message: str}, issuesInArchivedProjects: map{count: int(int64), issueIdsOrKeys: [str], message: str}, issuesInUnlicensedProjects: map{count: int(int64), issueIdsOrKeys: [str], message: str}, issuesNotFound: map{count: int(int64), issueIdsOrKeys: [str], message: str}, userDoesNotHavePermission: map{count: int(int64), issueIdsOrKeys: [str], message: str}}, numberOfIssuesUpdated: int(int64)}
@errors {400, 401, 403, 412}

@endpoint POST /rest/api/3/issue/bulk
@optional {issueUpdates: [map{fields: map, historyMetadata: any, properties: [map], transition: any, update: map}]}
@returns(201) {errors: [map], issues: [map]}
@errors {400, 401}

@endpoint POST /rest/api/3/issue/bulkfetch
@required {issueIdsOrKeys: [str]}
@optional {expand: [str], fields: [str], fieldsByKeys: bool, properties: [str]}
@returns(200) {issueErrors: [map], issues: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/issue/createmeta
@optional {projectIds: [str], projectKeys: [str], issuetypeIds: [str], issuetypeNames: [str], expand: str}
@returns(200) {expand: str, projects: [map]}
@errors {401}

@endpoint GET /rest/api/3/issue/createmeta/{projectIdOrKey}/issuetypes
@required {projectIdOrKey: str}
@optional {startAt: int(int32)=0, maxResults: int(int32)=50}
@returns(200) {createMetaIssueType: [map], issueTypes: [map], maxResults: int(int32), startAt: int(int64), total: int(int64)}
@errors {400, 401}

@endpoint GET /rest/api/3/issue/createmeta/{projectIdOrKey}/issuetypes/{issueTypeId}
@required {projectIdOrKey: str, issueTypeId: str}
@optional {startAt: int(int32)=0, maxResults: int(int32)=50}
@returns(200) {fields: [map], maxResults: int(int32), results: [map], startAt: int(int64), total: int(int64)}
@errors {400, 401}

@endpoint GET /rest/api/3/issue/limit/report
@optional {isReturningKeys: bool=false}
@returns(200) {issuesApproachingLimit: map, issuesBreachingLimit: map, limits: map}
@errors {401, 403}

@endpoint GET /rest/api/3/issue/picker
@optional {query: str, currentJQL: str, currentIssueKey: str, currentProjectId: str, showSubTasks: bool, showSubTaskParent: bool}
@returns(200) {sections: [map]}
@errors {401}

@endpoint POST /rest/api/3/issue/properties
@optional {entitiesIds: [int(int64)], properties: map}
@errors {303, 400, 401}

@endpoint POST /rest/api/3/issue/properties/multi
@optional {issues: [map{issueID: int(int64), properties: map}]}
@errors {303, 400, 401, 403}

@endpoint DELETE /rest/api/3/issue/properties/{propertyKey}
@required {propertyKey: str}
@optional {currentValue: any, entityIds: [int(int64)]}
@errors {303, 400, 401}

@endpoint PUT /rest/api/3/issue/properties/{propertyKey}
@required {propertyKey: str}
@optional {expression: str, filter: any, value: any}
@errors {303, 400, 401}

@endpoint PUT /rest/api/3/issue/unarchive
@optional {issueIdsOrKeys: [str]}
@returns(200) {errors: map{issueIsSubtask: map{count: int(int64), issueIdsOrKeys: [str], message: str}, issuesInArchivedProjects: map{count: int(int64), issueIdsOrKeys: [str], message: str}, issuesInUnlicensedProjects: map{count: int(int64), issueIdsOrKeys: [str], message: str}, issuesNotFound: map{count: int(int64), issueIdsOrKeys: [str], message: str}, userDoesNotHavePermission: map{count: int(int64), issueIdsOrKeys: [str], message: str}}, numberOfIssuesUpdated: int(int64)}
@errors {400, 401, 403, 412}

@endpoint POST /rest/api/3/issue/watching
@required {issueIds: [str]}
@returns(200) {issuesIsWatching: map}
@errors {401}

@endpoint DELETE /rest/api/3/issue/{issueIdOrKey}
@required {issueIdOrKey: str}
@optional {deleteSubtasks: str(true/false)=false}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}
@required {issueIdOrKey: str}
@optional {fields: [str], fieldsByKeys: bool=false, expand: str, properties: [str], updateHistory: bool=false, failFast: bool=false}
@returns(200) {changelog: any, editmeta: any, expand: str, fields: map, fieldsToInclude: map{actuallyIncluded: [str], excluded: [str], included: [str]}, id: str, key: str, names: map, operations: any, properties: map, renderedFields: map, schema: map, self: str(uri), transitions: [map], versionedRepresentations: map}
@errors {401, 404}

@endpoint PUT /rest/api/3/issue/{issueIdOrKey}
@required {issueIdOrKey: str}
@optional {notifyUsers: bool=true, overrideScreenSecurity: bool=false, overrideEditableFlag: bool=false, returnIssue: bool=false, expand: str=, fields: map, historyMetadata: any, properties: [map{key: str, value: any}], transition: any, update: map}
@returns(200)
@returns(204)
@errors {400, 401, 403, 404, 409, 422}

@endpoint PUT /rest/api/3/issue/{issueIdOrKey}/assignee
@required {issueIdOrKey: str}
@optional {accountId: str, accountType: str(atlassian/app/customer/unknown), active: bool, appType: str, applicationRoles: any, avatarUrls: any, displayName: str, emailAddress: str, expand: str, groups: any, guest: bool, key: str, locale: str, name: str, self: str(uri), timeZone: str}
@returns(204)
@errors {400, 403, 404}

@endpoint POST /rest/api/3/issue/{issueIdOrKey}/attachments
@required {issueIdOrKey: str}
@returns(200)
@errors {403, 404, 413}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}/changelog
@required {issueIdOrKey: str}
@optional {startAt: int(int32)=0, maxResults: int(int32)=100}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {404}

@endpoint POST /rest/api/3/issue/{issueIdOrKey}/changelog/list
@required {issueIdOrKey: str, changelogIds: [int(int64)]}
@returns(200) {histories: [map], maxResults: int(int32), startAt: int(int32), total: int(int32)}
@errors {400, 404}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}/comment
@required {issueIdOrKey: str}
@optional {startAt: int(int64)=0, maxResults: int(int32)=100, orderBy: str(created/-created/+created), expand: str}
@returns(200) {comments: [map], maxResults: int(int32), startAt: int(int64), total: int(int64)}
@errors {400, 401, 404}

@endpoint POST /rest/api/3/issue/{issueIdOrKey}/comment
@required {issueIdOrKey: str}
@optional {expand: str, author: any, body: any, created: str(date-time), id: str, jsdAuthorCanSeeRequest: bool, jsdPublic: bool, properties: [map{key: str, value: any}], renderedBody: str, self: str, updateAuthor: any, updated: str(date-time), visibility: any}
@returns(201) {author: any, body: any, created: str(date-time), id: str, jsdAuthorCanSeeRequest: bool, jsdPublic: bool, properties: [map], renderedBody: str, self: str, updateAuthor: any, updated: str(date-time), visibility: any}
@errors {400, 401, 404, 413}

@endpoint DELETE /rest/api/3/issue/{issueIdOrKey}/comment/{id}
@required {issueIdOrKey: str, id: str}
@returns(204)
@errors {400, 401, 404, 405}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}/comment/{id}
@required {issueIdOrKey: str, id: str}
@optional {expand: str}
@returns(200) {author: any, body: any, created: str(date-time), id: str, jsdAuthorCanSeeRequest: bool, jsdPublic: bool, properties: [map], renderedBody: str, self: str, updateAuthor: any, updated: str(date-time), visibility: any}
@errors {401, 404}

@endpoint PUT /rest/api/3/issue/{issueIdOrKey}/comment/{id}
@required {issueIdOrKey: str, id: str}
@optional {notifyUsers: bool=true, overrideEditableFlag: bool=false, expand: str, author: any, body: any, created: str(date-time), id: str, jsdAuthorCanSeeRequest: bool, jsdPublic: bool, properties: [map{key: str, value: any}], renderedBody: str, self: str, updateAuthor: any, updated: str(date-time), visibility: any}
@returns(200) {author: any, body: any, created: str(date-time), id: str, jsdAuthorCanSeeRequest: bool, jsdPublic: bool, properties: [map], renderedBody: str, self: str, updateAuthor: any, updated: str(date-time), visibility: any}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}/editmeta
@required {issueIdOrKey: str}
@optional {overrideScreenSecurity: bool=false, overrideEditableFlag: bool=false}
@returns(200) {fields: map}
@errors {401, 403, 404}

@endpoint POST /rest/api/3/issue/{issueIdOrKey}/notify
@required {issueIdOrKey: str}
@optional {htmlBody: str, restrict: any, subject: str, textBody: str, to: any}
@returns(204)
@errors {400, 403, 404}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}/properties
@required {issueIdOrKey: str}
@returns(200) {keys: [map]}
@errors {404}

@endpoint DELETE /rest/api/3/issue/{issueIdOrKey}/properties/{propertyKey}
@required {issueIdOrKey: str, propertyKey: str}
@returns(204)
@errors {401, 404}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}/properties/{propertyKey}
@required {issueIdOrKey: str, propertyKey: str}
@returns(200) {key: str, value: any}
@errors {401, 404}

@endpoint PUT /rest/api/3/issue/{issueIdOrKey}/properties/{propertyKey}
@required {issueIdOrKey: str, propertyKey: str}
@returns(200)
@returns(201)
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/issue/{issueIdOrKey}/remotelink
@required {issueIdOrKey: str, globalId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}/remotelink
@required {issueIdOrKey: str}
@optional {globalId: str}
@returns(200)
@errors {400, 401, 403, 404, 413}

@endpoint POST /rest/api/3/issue/{issueIdOrKey}/remotelink
@required {issueIdOrKey: str, object: any}
@optional {application: any, globalId: str, relationship: str}
@returns(200) {id: int(int64), self: str}
@returns(201) {id: int(int64), self: str}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/issue/{issueIdOrKey}/remotelink/{linkId}
@required {issueIdOrKey: str, linkId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}/remotelink/{linkId}
@required {issueIdOrKey: str, linkId: str}
@returns(200) {application: any, globalId: str, id: int(int64), object: any, relationship: str, self: str(uri)}
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/issue/{issueIdOrKey}/remotelink/{linkId}
@required {issueIdOrKey: str, linkId: str, object: any}
@optional {application: any, globalId: str, relationship: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}/transitions
@required {issueIdOrKey: str}
@optional {expand: str, transitionId: str, skipRemoteOnlyCondition: bool=false, includeUnavailableTransitions: bool=false, sortByOpsBarAndStatus: bool=false}
@returns(200) {expand: str, transitions: [map]}
@errors {401, 404}

@endpoint POST /rest/api/3/issue/{issueIdOrKey}/transitions
@required {issueIdOrKey: str}
@optional {fields: map, historyMetadata: any, properties: [map{key: str, value: any}], transition: any, update: map}
@returns(204)
@errors {400, 401, 404, 409, 413, 422}

@endpoint DELETE /rest/api/3/issue/{issueIdOrKey}/votes
@required {issueIdOrKey: str}
@returns(204)
@errors {401, 404}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}/votes
@required {issueIdOrKey: str}
@returns(200) {hasVoted: bool, self: str(uri), voters: [map], votes: int(int64)}
@errors {401, 404}

@endpoint POST /rest/api/3/issue/{issueIdOrKey}/votes
@required {issueIdOrKey: str}
@returns(204)
@errors {400, 401, 404}

@endpoint DELETE /rest/api/3/issue/{issueIdOrKey}/watchers
@required {issueIdOrKey: str}
@optional {username: str, accountId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}/watchers
@required {issueIdOrKey: str}
@returns(200) {isWatching: bool, self: str, watchCount: int(int32), watchers: [map]}
@errors {401, 404}

@endpoint POST /rest/api/3/issue/{issueIdOrKey}/watchers
@required {issueIdOrKey: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/issue/{issueIdOrKey}/worklog
@required {issueIdOrKey: str, ids: [int(int64)]}
@optional {adjustEstimate: str(leave/auto)=auto, overrideEditableFlag: bool=false}
@returns(200)
@returns(204)
@errors {400, 401, 404}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}/worklog
@required {issueIdOrKey: str}
@optional {startAt: int(int64)=0, maxResults: int(int32)=5000, startedAfter: int(int64), startedBefore: int(int64), expand: str=}
@returns(200) {maxResults: int(int32), startAt: int(int32), total: int(int32), worklogs: [map]}
@errors {401, 404}

@endpoint POST /rest/api/3/issue/{issueIdOrKey}/worklog
@required {issueIdOrKey: str}
@optional {notifyUsers: bool=true, adjustEstimate: str(new/leave/manual/auto)=auto, newEstimate: str, reduceBy: str, expand: str=, overrideEditableFlag: bool=false, author: any, comment: any, created: str(date-time), id: str, issueId: str, properties: [map{key: str, value: any}], self: str(uri), started: str(date-time), timeSpent: str, timeSpentSeconds: int(int64), updateAuthor: any, updated: str(date-time), visibility: any}
@returns(201) {author: any, comment: any, created: str(date-time), id: str, issueId: str, properties: [map], self: str(uri), started: str(date-time), timeSpent: str, timeSpentSeconds: int(int64), updateAuthor: any, updated: str(date-time), visibility: any}
@errors {400, 401, 404, 413}

@endpoint POST /rest/api/3/issue/{issueIdOrKey}/worklog/move
@required {issueIdOrKey: str}
@optional {adjustEstimate: str(leave/auto)=auto, overrideEditableFlag: bool=false, ids: [int(int64)], issueIdOrKey: str}
@returns(200)
@returns(204)
@errors {400, 401, 404}

@endpoint DELETE /rest/api/3/issue/{issueIdOrKey}/worklog/{id}
@required {issueIdOrKey: str, id: str}
@optional {notifyUsers: bool=true, adjustEstimate: str(new/leave/manual/auto)=auto, newEstimate: str, increaseBy: str, overrideEditableFlag: bool=false}
@returns(204)
@errors {400, 401, 404}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}/worklog/{id}
@required {issueIdOrKey: str, id: str}
@optional {expand: str=}
@returns(200) {author: any, comment: any, created: str(date-time), id: str, issueId: str, properties: [map], self: str(uri), started: str(date-time), timeSpent: str, timeSpentSeconds: int(int64), updateAuthor: any, updated: str(date-time), visibility: any}
@errors {401, 404}

@endpoint PUT /rest/api/3/issue/{issueIdOrKey}/worklog/{id}
@required {issueIdOrKey: str, id: str}
@optional {notifyUsers: bool=true, adjustEstimate: str(new/leave/manual/auto)=auto, newEstimate: str, expand: str=, overrideEditableFlag: bool=false, author: any, comment: any, created: str(date-time), id: str, issueId: str, properties: [map{key: str, value: any}], self: str(uri), started: str(date-time), timeSpent: str, timeSpentSeconds: int(int64), updateAuthor: any, updated: str(date-time), visibility: any}
@returns(200) {author: any, comment: any, created: str(date-time), id: str, issueId: str, properties: [map], self: str(uri), started: str(date-time), timeSpent: str, timeSpentSeconds: int(int64), updateAuthor: any, updated: str(date-time), visibility: any}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}/worklog/{worklogId}/properties
@required {issueIdOrKey: str, worklogId: str}
@returns(200) {keys: [map]}
@errors {400, 401, 404}

@endpoint DELETE /rest/api/3/issue/{issueIdOrKey}/worklog/{worklogId}/properties/{propertyKey}
@required {issueIdOrKey: str, worklogId: str, propertyKey: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/issue/{issueIdOrKey}/worklog/{worklogId}/properties/{propertyKey}
@required {issueIdOrKey: str, worklogId: str, propertyKey: str}
@returns(200) {key: str, value: any}
@errors {400, 401, 404}

@endpoint PUT /rest/api/3/issue/{issueIdOrKey}/worklog/{worklogId}/properties/{propertyKey}
@required {issueIdOrKey: str, worklogId: str, propertyKey: str}
@returns(200)
@returns(201)
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/issueLink
@required {inwardIssue: map{fields: any, id: str, key: str, self: str(uri)}, outwardIssue: map{fields: any, id: str, key: str, self: str(uri)}, type: map{id: str, inward: str, name: str, outward: str, self: str(uri)}}
@optional {comment: map{author: any, body: any, created: str(date-time), id: str, jsdAuthorCanSeeRequest: bool, jsdPublic: bool, properties: [map], renderedBody: str, self: str, updateAuthor: any, updated: str(date-time), visibility: any}}
@returns(201)
@errors {400, 401, 404, 413}

@endpoint DELETE /rest/api/3/issueLink/{linkId}
@required {linkId: str}
@returns(200)
@returns(204)
@errors {400, 401, 404}

@endpoint GET /rest/api/3/issueLink/{linkId}
@required {linkId: str}
@returns(200) {id: str, inwardIssue: any, outwardIssue: any, self: str(uri), type: any}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/issueLinkType
@returns(200) {issueLinkTypes: [map]}
@errors {401, 404}

@endpoint POST /rest/api/3/issueLinkType
@optional {id: str, inward: str, name: str, outward: str, self: str(uri)}
@returns(201) {id: str, inward: str, name: str, outward: str, self: str(uri)}
@errors {400, 401, 404}

@endpoint DELETE /rest/api/3/issueLinkType/{issueLinkTypeId}
@required {issueLinkTypeId: str}
@returns(204)
@errors {400, 401, 404}

@endpoint GET /rest/api/3/issueLinkType/{issueLinkTypeId}
@required {issueLinkTypeId: str}
@returns(200) {id: str, inward: str, name: str, outward: str, self: str(uri)}
@errors {400, 401, 404}

@endpoint PUT /rest/api/3/issueLinkType/{issueLinkTypeId}
@required {issueLinkTypeId: str}
@optional {id: str, inward: str, name: str, outward: str, self: str(uri)}
@returns(200) {id: str, inward: str, name: str, outward: str, self: str(uri)}
@errors {400, 401, 404}

@endpoint PUT /rest/api/3/issues/archive/export
@optional {archivedBy: [str], archivedDateRange: map{dateAfter!: str, dateBefore!: str}, issueTypes: [str], projects: [str], reporters: [str]}
@returns(202) {fileUrl: str, payload: str, progress: int(int64), status: str, submittedTime: str(date-time), taskId: str}
@errors {400, 401, 403, 412}

@endpoint GET /rest/api/3/issuesecurityschemes
@returns(200) {issueSecuritySchemes: [map]}
@errors {401, 403}

@endpoint POST /rest/api/3/issuesecurityschemes
@required {name: str}
@optional {description: str, levels: [map{description: str, isDefault: bool, members: [map], name!: str}]}
@returns(201) {id: str}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/issuesecurityschemes/level
@optional {startAt: str=0, maxResults: str=50, id: [str], schemeId: [str], onlyDefault: bool=false}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint PUT /rest/api/3/issuesecurityschemes/level/default
@required {defaultValues: [map{defaultLevelId!: str, issueSecuritySchemeId!: str}]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/issuesecurityschemes/level/member
@optional {startAt: str=0, maxResults: str=50, id: [str], schemeId: [str], levelId: [str], expand: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/issuesecurityschemes/project
@optional {startAt: str=0, maxResults: str=50, issueSecuritySchemeId: [str], projectId: [str]}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint PUT /rest/api/3/issuesecurityschemes/project
@required {projectId: str, schemeId: str}
@optional {oldToNewSecurityLevelMappings: [map{newLevelId!: str, oldLevelId!: str}]}
@errors {303, 400, 401, 403, 404, 409}

@endpoint GET /rest/api/3/issuesecurityschemes/search
@optional {startAt: str=0, maxResults: str=50, id: [str], projectId: [str]}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/issuesecurityschemes/{id}
@required {id: int(int64)}
@returns(200) {defaultSecurityLevelId: int(int64), description: str, id: int(int64), levels: [map], name: str, self: str}
@errors {401, 403}

@endpoint PUT /rest/api/3/issuesecurityschemes/{id}
@required {id: str}
@optional {description: str, name: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/issuesecurityschemes/{issueSecuritySchemeId}/members
@required {issueSecuritySchemeId: int(int64)}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, issueSecurityLevelId: [str], expand: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/issuesecurityschemes/{schemeId}
@required {schemeId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/issuesecurityschemes/{schemeId}/level
@required {schemeId: str}
@optional {levels: [map{description: str, isDefault: bool, members: [map], name!: str}]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/issuesecurityschemes/{schemeId}/level/{levelId}
@required {schemeId: str, levelId: str}
@optional {replaceWith: str}
@errors {303, 400, 401, 403, 404, 409}

@endpoint PUT /rest/api/3/issuesecurityschemes/{schemeId}/level/{levelId}
@required {schemeId: str, levelId: str}
@optional {description: str, name: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/issuesecurityschemes/{schemeId}/level/{levelId}/member
@required {schemeId: str, levelId: str}
@optional {members: [map{parameter: str, type!: str}]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/issuesecurityschemes/{schemeId}/level/{levelId}/member/{memberId}
@required {schemeId: str, levelId: str, memberId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/issuetype
@returns(200)

@endpoint POST /rest/api/3/issuetype
@required {name: str}
@optional {description: str, hierarchyLevel: int(int32), type: str(subtask/standard)}
@returns(201) {avatarId: int(int64), description: str, entityId: str(uuid), hierarchyLevel: int(int32), iconUrl: str, id: str, name: str, scope: any, self: str, subtask: bool}
@errors {400, 401, 403, 409}

@endpoint GET /rest/api/3/issuetype/project
@required {projectId: int(int64)}
@optional {level: int(int32)}
@returns(200)
@errors {400, 404}

@endpoint DELETE /rest/api/3/issuetype/{id}
@required {id: str}
@optional {alternativeIssueTypeId: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 423}

@endpoint GET /rest/api/3/issuetype/{id}
@required {id: str}
@returns(200) {avatarId: int(int64), description: str, entityId: str(uuid), hierarchyLevel: int(int32), iconUrl: str, id: str, name: str, scope: any, self: str, subtask: bool}
@errors {400, 404}

@endpoint PUT /rest/api/3/issuetype/{id}
@required {id: str}
@optional {avatarId: int(int64), description: str, name: str}
@returns(200) {avatarId: int(int64), description: str, entityId: str(uuid), hierarchyLevel: int(int32), iconUrl: str, id: str, name: str, scope: any, self: str, subtask: bool}
@errors {400, 401, 403, 404, 409}

@endpoint GET /rest/api/3/issuetype/{id}/alternatives
@required {id: str}
@returns(200)
@errors {404}

@endpoint POST /rest/api/3/issuetype/{id}/avatar2
@required {id: str, size: int(int32)}
@optional {x: int(int32)=0, y: int(int32)=0}
@returns(201) {fileName: str, id: str, isDeletable: bool, isSelected: bool, isSystemAvatar: bool, owner: str, urls: map}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/issuetype/{issueTypeId}/properties
@required {issueTypeId: str}
@returns(200) {keys: [map]}
@errors {400, 404}

@endpoint DELETE /rest/api/3/issuetype/{issueTypeId}/properties/{propertyKey}
@required {issueTypeId: str, propertyKey: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/issuetype/{issueTypeId}/properties/{propertyKey}
@required {issueTypeId: str, propertyKey: str}
@returns(200) {key: str, value: any}
@errors {400, 401, 404}

@endpoint PUT /rest/api/3/issuetype/{issueTypeId}/properties/{propertyKey}
@required {issueTypeId: str, propertyKey: str}
@returns(200)
@returns(201)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/issuetypescheme
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, id: [int(int64)], orderBy: str(name/-name/+name/id/-id/+id)=id, expand: str=, queryString: str=}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint POST /rest/api/3/issuetypescheme
@required {issueTypeIds: [str], name: str}
@optional {defaultIssueTypeId: str, description: str}
@returns(201) {issueTypeSchemeId: str}
@errors {400, 401, 403, 409}

@endpoint GET /rest/api/3/issuetypescheme/mapping
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, issueTypeSchemeId: [int(int64)]}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/issuetypescheme/project
@required {projectId: [int(int64)]}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint PUT /rest/api/3/issuetypescheme/project
@required {issueTypeSchemeId: str, projectId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/issuetypescheme/{issueTypeSchemeId}
@required {issueTypeSchemeId: int(int64)}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/issuetypescheme/{issueTypeSchemeId}
@required {issueTypeSchemeId: int(int64)}
@optional {defaultIssueTypeId: str, description: str, name: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/issuetypescheme/{issueTypeSchemeId}/issuetype
@required {issueTypeSchemeId: int(int64), issueTypeIds: [str]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/issuetypescheme/{issueTypeSchemeId}/issuetype/move
@required {issueTypeSchemeId: int(int64), issueTypeIds: [str]}
@optional {after: str, position: str(First/Last)}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/issuetypescheme/{issueTypeSchemeId}/issuetype/{issueTypeId}
@required {issueTypeSchemeId: int(int64), issueTypeId: int(int64)}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/issuetypescreenscheme
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, id: [int(int64)], queryString: str=, orderBy: str(name/-name/+name/id/-id/+id)=id, expand: str=}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint POST /rest/api/3/issuetypescreenscheme
@required {issueTypeMappings: [map{issueTypeId!: str, screenSchemeId!: str}], name: str}
@optional {description: str}
@returns(201) {id: str}
@errors {400, 401, 403, 404, 409}

@endpoint GET /rest/api/3/issuetypescreenscheme/mapping
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, issueTypeScreenSchemeId: [int(int64)]}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/issuetypescreenscheme/project
@required {projectId: [int(int64)]}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint PUT /rest/api/3/issuetypescreenscheme/project
@optional {issueTypeScreenSchemeId: str, projectId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/issuetypescreenscheme/{issueTypeScreenSchemeId}
@required {issueTypeScreenSchemeId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/issuetypescreenscheme/{issueTypeScreenSchemeId}
@required {issueTypeScreenSchemeId: str}
@optional {description: str, name: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/issuetypescreenscheme/{issueTypeScreenSchemeId}/mapping
@required {issueTypeScreenSchemeId: str, issueTypeMappings: [map{issueTypeId!: str, screenSchemeId!: str}]}
@returns(204)
@errors {400, 401, 403, 404, 409}

@endpoint PUT /rest/api/3/issuetypescreenscheme/{issueTypeScreenSchemeId}/mapping/default
@required {issueTypeScreenSchemeId: str, screenSchemeId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/issuetypescreenscheme/{issueTypeScreenSchemeId}/mapping/remove
@required {issueTypeScreenSchemeId: str, issueTypeIds: [str]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/issuetypescreenscheme/{issueTypeScreenSchemeId}/project
@required {issueTypeScreenSchemeId: int(int64)}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, query: str=}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/jql/autocompletedata
@returns(200) {jqlReservedWords: [str], visibleFieldNames: [map], visibleFunctionNames: [map]}
@errors {401}

@endpoint POST /rest/api/3/jql/autocompletedata
@optional {includeCollapsedFields: bool=false, projectIds: [int(int64)]}
@returns(200) {jqlReservedWords: [str], visibleFieldNames: [map], visibleFunctionNames: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/jql/autocompletedata/suggestions
@optional {fieldName: str, fieldValue: str, predicateName: str, predicateValue: str}
@returns(200) {results: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/jql/function/computation
@optional {functionKey: [str], startAt: int(int64)=0, maxResults: int(int32)=100, orderBy: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/jql/function/computation
@optional {skipNotFoundPrecomputations: bool=false, values: [map{error: str, id!: str, value: str}]}
@returns(200) {notFoundPrecomputationIDs: [str]}
@returns(204)
@errors {400, 403, 404}

@endpoint POST /rest/api/3/jql/function/computation/search
@optional {orderBy: str, precomputationIDs: [str]}
@returns(200) {notFoundPrecomputationIDs: [str], precomputations: [map]}
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/jql/match
@required {issueIds: [int(int64)], jqls: [str]}
@returns(200) {matches: [map]}
@errors {400}

@endpoint POST /rest/api/3/jql/parse
@required {validation: str(strict/warn/none)=strict, queries: [str]}
@returns(200) {queries: [map]}
@errors {400, 401}

@endpoint POST /rest/api/3/jql/pdcleaner
@optional {queryStrings: [str]}
@returns(200) {queriesWithUnknownUsers: [map], queryStrings: [str]}
@errors {400, 401}

@endpoint POST /rest/api/3/jql/sanitize
@required {queries: [map{accountId: str, query!: str}]}
@returns(200) {queries: [map]}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/label
@optional {startAt: int(int64)=0, maxResults: int(int32)=1000}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [str]}

@endpoint GET /rest/api/3/license/approximateLicenseCount
@returns(200) {key: str, value: str}
@errors {401, 403}

@endpoint GET /rest/api/3/license/approximateLicenseCount/product/{applicationKey}
@required {applicationKey: str(jira-core/jira-product-discovery/jira-software/jira-servicedesk)}
@returns(200) {key: str, value: str}
@errors {401, 403}

@endpoint GET /rest/api/3/mypermissions
@optional {projectKey: str, projectId: str, issueKey: str, issueId: str, permissions: str, projectUuid: str, projectConfigurationUuid: str, commentId: str}
@returns(200) {permissions: map}
@errors {400, 401, 404}

@endpoint DELETE /rest/api/3/mypreferences
@required {key: str}
@returns(204)
@errors {401, 404}

@endpoint GET /rest/api/3/mypreferences
@required {key: str}
@returns(200)
@errors {401, 404}

@endpoint PUT /rest/api/3/mypreferences
@required {key: str}
@returns(204)
@errors {401, 404}

@endpoint GET /rest/api/3/mypreferences/locale
@returns(200) {locale: str}
@errors {401}

@endpoint PUT /rest/api/3/mypreferences/locale
@optional {locale: str}
@returns(204)
@errors {400, 401}

@endpoint GET /rest/api/3/myself
@optional {expand: str}
@returns(200) {accountId: str, accountType: str, active: bool, appType: str, applicationRoles: any, avatarUrls: any, displayName: str, emailAddress: str, expand: str, groups: any, guest: bool, key: str, locale: str, name: str, self: str(uri), timeZone: str}
@errors {401}

@endpoint GET /rest/api/3/notificationscheme
@optional {startAt: str=0, maxResults: str=50, id: [str], projectId: [str], onlyDefault: bool=false, expand: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401}

@endpoint POST /rest/api/3/notificationscheme
@required {name: str}
@optional {description: str, notificationSchemeEvents: [map{event!: any, notifications!: [map]}]}
@returns(201) {id: str}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/notificationscheme/project
@optional {startAt: str=0, maxResults: str=50, notificationSchemeId: [str], projectId: [str]}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/notificationscheme/{id}
@required {id: int(int64)}
@optional {expand: str}
@returns(200) {description: str, expand: str, id: int(int64), name: str, notificationSchemeEvents: [map], projects: [int(int64)], scope: any, self: str}
@errors {400, 401, 404}

@endpoint PUT /rest/api/3/notificationscheme/{id}
@required {id: str}
@optional {description: str, name: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/notificationscheme/{id}/notification
@required {id: str, notificationSchemeEvents: [map{event!: any, notifications!: [map]}]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/notificationscheme/{notificationSchemeId}
@required {notificationSchemeId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/notificationscheme/{notificationSchemeId}/notification/{notificationId}
@required {notificationSchemeId: str, notificationId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/permissions
@returns(200) {permissions: map}
@errors {401, 403}

@endpoint POST /rest/api/3/permissions/check
@optional {accountId: str, globalPermissions: [str], projectPermissions: [map{issues: [int(int64)], permissions!: [str], projects: [int(int64)]}]}
@returns(200) {globalPermissions: [str], projectPermissions: [map]}
@errors {400, 403}

@endpoint POST /rest/api/3/permissions/project
@required {permissions: [str]}
@returns(200) {projects: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/permissionscheme
@optional {expand: str}
@returns(200) {permissionSchemes: [map]}
@errors {401}

@endpoint POST /rest/api/3/permissionscheme
@required {name: str}
@optional {expand: str, description: str, expand: str, id: int(int64), permissions: [map{holder: any, id: int(int64), permission: str, self: str(uri)}], scope: any, self: str(uri)}
@returns(201) {description: str, expand: str, id: int(int64), name: str, permissions: [map], scope: any, self: str(uri)}
@errors {400, 401, 403}

@endpoint DELETE /rest/api/3/permissionscheme/{schemeId}
@required {schemeId: int(int64)}
@returns(204)
@errors {401, 403, 404}

@endpoint GET /rest/api/3/permissionscheme/{schemeId}
@required {schemeId: int(int64)}
@optional {expand: str}
@returns(200) {description: str, expand: str, id: int(int64), name: str, permissions: [map], scope: any, self: str(uri)}
@errors {401, 404}

@endpoint PUT /rest/api/3/permissionscheme/{schemeId}
@required {schemeId: int(int64), name: str}
@optional {expand: str, description: str, expand: str, id: int(int64), permissions: [map{holder: any, id: int(int64), permission: str, self: str(uri)}], scope: any, self: str(uri)}
@returns(200) {description: str, expand: str, id: int(int64), name: str, permissions: [map], scope: any, self: str(uri)}
@errors {401, 403, 404}

@endpoint GET /rest/api/3/permissionscheme/{schemeId}/permission
@required {schemeId: int(int64)}
@optional {expand: str}
@returns(200) {expand: str, permissions: [map]}
@errors {401, 404}

@endpoint POST /rest/api/3/permissionscheme/{schemeId}/permission
@required {schemeId: int(int64)}
@optional {expand: str, holder: any, id: int(int64), permission: str, self: str(uri)}
@returns(201) {holder: any, id: int(int64), permission: str, self: str(uri)}
@errors {400, 401, 403}

@endpoint DELETE /rest/api/3/permissionscheme/{schemeId}/permission/{permissionId}
@required {schemeId: int(int64), permissionId: int(int64)}
@returns(204)
@errors {400, 401, 403}

@endpoint GET /rest/api/3/permissionscheme/{schemeId}/permission/{permissionId}
@required {schemeId: int(int64), permissionId: int(int64)}
@optional {expand: str}
@returns(200) {holder: any, id: int(int64), permission: str, self: str(uri)}
@errors {401, 404}

@endpoint GET /rest/api/3/plans/plan
@optional {includeTrashed: bool=false, includeArchived: bool=false, cursor: str=, maxResults: int(int32)=50}
@returns(200) {cursor: str, last: bool, nextPageCursor: str, size: int(int32), total: int(int64), values: [map]}
@errors {401, 403}

@endpoint POST /rest/api/3/plans/plan
@required {issueSources: [map{type!: str, value!: int(int64)}], name: str, scheduling: any}
@optional {useGroupId: bool=false, crossProjectReleases: [map{name!: str, releaseIds: [int(int64)]}], customFields: [map{customFieldId!: int(int64), filter: bool}], exclusionRules: any, leadAccountId: str, permissions: [map{holder!: any, type!: str}]}
@returns(201)
@errors {400, 401, 403}

@endpoint GET /rest/api/3/plans/plan/{planId}
@required {planId: int(int64)}
@optional {useGroupId: bool=false}
@returns(200) {crossProjectReleases: [map], customFields: [map], exclusionRules: any, id: int(int64), issueSources: [map], lastSaved: str, leadAccountId: str, name: str, permissions: [map], scheduling: any, status: str}
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/plans/plan/{planId}
@required {planId: int(int64)}
@optional {useGroupId: bool=false}
@returns(204)
@errors {400, 401, 403, 404, 409}

@endpoint PUT /rest/api/3/plans/plan/{planId}/archive
@required {planId: int(int64)}
@returns(204)
@errors {401, 403, 404, 409}

@endpoint POST /rest/api/3/plans/plan/{planId}/duplicate
@required {planId: int(int64), name: str}
@returns(201)
@errors {400, 401, 403, 404, 409}

@endpoint GET /rest/api/3/plans/plan/{planId}/team
@required {planId: int(int64)}
@optional {cursor: str=, maxResults: int(int32)=50}
@returns(200) {cursor: str, last: bool, nextPageCursor: str, size: int(int32), total: int(int64), values: [map]}
@errors {401, 403, 404}

@endpoint POST /rest/api/3/plans/plan/{planId}/team/atlassian
@required {planId: int(int64), id: str, planningStyle: str(Scrum/Kanban)}
@optional {capacity: num(double), issueSourceId: int(int64), sprintLength: int(int64)}
@returns(204)
@errors {400, 401, 403, 404, 409}

@endpoint DELETE /rest/api/3/plans/plan/{planId}/team/atlassian/{atlassianTeamId}
@required {planId: int(int64), atlassianTeamId: str}
@returns(204)
@errors {401, 403, 404, 409}

@endpoint GET /rest/api/3/plans/plan/{planId}/team/atlassian/{atlassianTeamId}
@required {planId: int(int64), atlassianTeamId: str}
@returns(200) {capacity: num(double), id: str, issueSourceId: int(int64), planningStyle: str, sprintLength: int(int64)}
@errors {401, 403, 404, 409}

@endpoint PUT /rest/api/3/plans/plan/{planId}/team/atlassian/{atlassianTeamId}
@required {planId: int(int64), atlassianTeamId: str}
@returns(204)
@errors {400, 401, 403, 404, 409}

@endpoint POST /rest/api/3/plans/plan/{planId}/team/planonly
@required {planId: int(int64), name: str, planningStyle: str(Scrum/Kanban)}
@optional {capacity: num(double), issueSourceId: int(int64), memberAccountIds: [str], sprintLength: int(int64)}
@returns(201)
@errors {400, 401, 403, 404, 409}

@endpoint DELETE /rest/api/3/plans/plan/{planId}/team/planonly/{planOnlyTeamId}
@required {planId: int(int64), planOnlyTeamId: int(int64)}
@returns(204)
@errors {401, 403, 404, 409}

@endpoint GET /rest/api/3/plans/plan/{planId}/team/planonly/{planOnlyTeamId}
@required {planId: int(int64), planOnlyTeamId: int(int64)}
@returns(200) {capacity: num(double), id: int(int64), issueSourceId: int(int64), memberAccountIds: [str], name: str, planningStyle: str, sprintLength: int(int64)}
@errors {401, 403, 404, 409}

@endpoint PUT /rest/api/3/plans/plan/{planId}/team/planonly/{planOnlyTeamId}
@required {planId: int(int64), planOnlyTeamId: int(int64)}
@returns(204)
@errors {400, 401, 403, 404, 409}

@endpoint PUT /rest/api/3/plans/plan/{planId}/trash
@required {planId: int(int64)}
@returns(204)
@errors {401, 403, 404, 409}

@endpoint GET /rest/api/3/priority
@returns(200)
@errors {401}

@endpoint POST /rest/api/3/priority
@required {name: str, statusColor: str}
@optional {avatarId: int(int64), description: str, iconUrl: str(/images/icons/priorities/blocker.png//images/icons/priorities/critical.png//images/icons/priorities/high.png//images/icons/priorities/highest.png//images/icons/priorities/low.png//images/icons/priorities/lowest.png//images/icons/priorities/major.png//images/icons/priorities/medium.png//images/icons/priorities/minor.png//images/icons/priorities/trivial.png//images/icons/priorities/blocker_new.png//images/icons/priorities/critical_new.png//images/icons/priorities/high_new.png//images/icons/priorities/highest_new.png//images/icons/priorities/low_new.png//images/icons/priorities/lowest_new.png//images/icons/priorities/major_new.png//images/icons/priorities/medium_new.png//images/icons/priorities/minor_new.png//images/icons/priorities/trivial_new.png)}
@returns(201) {id: str}
@errors {400, 401, 403}

@endpoint PUT /rest/api/3/priority/default
@required {id: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/priority/move
@required {ids: [str]}
@optional {after: str, position: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/priority/search
@optional {startAt: str=0, maxResults: str=50, id: [str], projectId: [str], priorityName: str=, onlyDefault: bool=false, expand: str=}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401}

@endpoint DELETE /rest/api/3/priority/{id}
@required {id: str}
@errors {303, 400, 401, 403, 404, 409}

@endpoint GET /rest/api/3/priority/{id}
@required {id: str}
@returns(200) {avatarId: int(int64), description: str, iconUrl: str, id: str, isDefault: bool, name: str, schemes: any, self: str, statusColor: str}
@errors {401, 404}

@endpoint PUT /rest/api/3/priority/{id}
@required {id: str}
@optional {avatarId: int(int64), description: str, iconUrl: str(/images/icons/priorities/blocker.png//images/icons/priorities/critical.png//images/icons/priorities/high.png//images/icons/priorities/highest.png//images/icons/priorities/low.png//images/icons/priorities/lowest.png//images/icons/priorities/major.png//images/icons/priorities/medium.png//images/icons/priorities/minor.png//images/icons/priorities/trivial.png//images/icons/priorities/blocker_new.png//images/icons/priorities/critical_new.png//images/icons/priorities/high_new.png//images/icons/priorities/highest_new.png//images/icons/priorities/low_new.png//images/icons/priorities/lowest_new.png//images/icons/priorities/major_new.png//images/icons/priorities/medium_new.png//images/icons/priorities/minor_new.png//images/icons/priorities/trivial_new.png), name: str, statusColor: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/priorityscheme
@optional {startAt: str=0, maxResults: str=50, priorityId: [int(int64)], schemeId: [int(int64)], schemeName: str=, onlyDefault: bool=false, orderBy: str(name/+name/-name)=+name, expand: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401}

@endpoint POST /rest/api/3/priorityscheme
@required {defaultPriorityId: int(int64), name: str, priorityIds: [int(int64)]}
@optional {description: str, mappings: any, projectIds: [int(int64)]}
@returns(201) {id: str, task: any}
@returns(202) {id: str, task: any}
@errors {400, 401, 403, 409}

@endpoint POST /rest/api/3/priorityscheme/mappings
@optional {maxResults: int(int32), priorities: any, projects: any, schemeId: int(int64), startAt: int(int64)}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/priorityscheme/priorities/available
@required {schemeId: str}
@optional {startAt: str=0, maxResults: str=50, query: str=, exclude: [str]}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401}

@endpoint DELETE /rest/api/3/priorityscheme/{schemeId}
@required {schemeId: int(int64)}
@returns(204)
@errors {400, 401, 403}

@endpoint PUT /rest/api/3/priorityscheme/{schemeId}
@required {schemeId: int(int64)}
@optional {defaultPriorityId: int(int64), description: str, mappings: any, name: str, priorities: any, projects: any}
@returns(202) {priorityScheme: map{default: bool, defaultPriorityId: str, description: str, id: str, isDefault: bool, name: str, priorities: any, projects: any, self: str}, task: any}
@errors {400, 401, 403, 409}

@endpoint GET /rest/api/3/priorityscheme/{schemeId}/priorities
@required {schemeId: str}
@optional {startAt: str=0, maxResults: str=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/priorityscheme/{schemeId}/projects
@required {schemeId: str}
@optional {startAt: str=0, maxResults: str=50, projectId: [int(int64)], query: str=}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/project
@optional {expand: str, recent: int(int32), properties: [str]}
@returns(200)
@errors {401}

@endpoint POST /rest/api/3/project
@required {key: str, name: str}
@optional {assigneeType: str(PROJECT_LEAD/UNASSIGNED), avatarId: int(int64), categoryId: int(int64), description: str, fieldConfigurationScheme: int(int64), fieldScheme: int(int64), issueSecurityScheme: int(int64), issueTypeScheme: int(int64), issueTypeScreenScheme: int(int64), lead: str, leadAccountId: str, notificationScheme: int(int64), permissionScheme: int(int64), projectTemplateKey: str(com.pyxis.greenhopper.jira:gh-simplified-agility-kanban/com.pyxis.greenhopper.jira:gh-simplified-agility-scrum/com.pyxis.greenhopper.jira:gh-simplified-basic/com.pyxis.greenhopper.jira:gh-simplified-kanban-classic/com.pyxis.greenhopper.jira:gh-simplified-scrum-classic/com.pyxis.greenhopper.jira:gh-cross-team-template/com.pyxis.greenhopper.jira:gh-cross-team-planning-template/com.atlassian.servicedesk:simplified-it-service-management/com.atlassian.servicedesk:simplified-it-service-management-basic/com.atlassian.servicedesk:simplified-it-service-management-operations/com.atlassian.servicedesk:simplified-general-service-desk/com.atlassian.servicedesk:simplified-internal-service-desk/com.atlassian.servicedesk:simplified-external-service-desk/com.atlassian.servicedesk:simplified-hr-service-desk/com.atlassian.servicedesk:simplified-facilities-service-desk/com.atlassian.servicedesk:simplified-legal-service-desk/com.atlassian.servicedesk:simplified-marketing-service-desk/com.atlassian.servicedesk:simplified-finance-service-desk/com.atlassian.servicedesk:simplified-analytics-service-desk/com.atlassian.servicedesk:simplified-design-service-desk/com.atlassian.servicedesk:simplified-sales-service-desk/com.atlassian.servicedesk:simplified-halp-service-desk/com.atlassian.servicedesk:next-gen-it-service-desk/com.atlassian.servicedesk:next-gen-hr-service-desk/com.atlassian.servicedesk:next-gen-legal-service-desk/com.atlassian.servicedesk:next-gen-marketing-service-desk/com.atlassian.servicedesk:next-gen-facilities-service-desk/com.atlassian.servicedesk:next-gen-general-service-desk/com.atlassian.servicedesk:next-gen-analytics-service-desk/com.atlassian.servicedesk:next-gen-finance-service-desk/com.atlassian.servicedesk:next-gen-design-service-desk/com.atlassian.servicedesk:next-gen-sales-service-desk/com.atlassian.jira-core-project-templates:jira-core-simplified-content-management/com.atlassian.jira-core-project-templates:jira-core-simplified-document-approval/com.atlassian.jira-core-project-templates:jira-core-simplified-lead-tracking/com.atlassian.jira-core-project-templates:jira-core-simplified-process-control/com.atlassian.jira-core-project-templates:jira-core-simplified-procurement/com.atlassian.jira-core-project-templates:jira-core-simplified-project-management/com.atlassian.jira-core-project-templates:jira-core-simplified-recruitment/com.atlassian.jira-core-project-templates:jira-core-simplified-task-/com.atlassian.jcs:customer-service-management), projectTypeKey: str(software/service_desk/business), url: str, workflowScheme: int(int64)}
@returns(201) {id: int(int64), key: str, self: str(uri)}
@errors {400, 401, 403}

@endpoint POST /rest/api/3/project-template
@optional {details: map{accessLevel: str, additionalProperties: map, assigneeType: str, avatarId: int(int64), categoryId: int(int64), description: str, enableComponents: bool, key: str, language: str, leadAccountId: str, name: str, url: str}, template: map{boards: map, field: map, issueType: map, notification: map, permissionScheme: map, project: map, role: map, scope: map, security: map, workflow: map}}
@errors {303}

@endpoint PUT /rest/api/3/project-template/edit-template
@optional {templateDescription: str, templateGenerationOptions: map{enableScreenDelegatedAdminSupport: bool, enableWorkflowDelegatedAdminSupport: bool}, templateKey: str, templateName: str}
@returns(200)

@endpoint GET /rest/api/3/project-template/live-template
@optional {projectId: str, templateKey: str}
@returns(200) {archetype: map{realType: str, style: str, type: str}, defaultBoardView: str, description: str, liveTemplateProjectIdReference: int(int64), name: str, projectTemplateKey: map{key: str, uuid: str(uuid)}, snapshotTemplate: map, templateGenerationOptions: map{enableScreenDelegatedAdminSupport: bool, enableWorkflowDelegatedAdminSupport: bool}, type: str}

@endpoint DELETE /rest/api/3/project-template/remove-template
@required {templateKey: str}
@returns(200)

@endpoint POST /rest/api/3/project-template/save-template
@optional {templateDescription: str, templateFromProjectRequest: map{projectId: int(int64), templateGenerationOptions: map, templateType: str}, templateName: str}
@returns(200) {projectTemplateKey: map{key: str, uuid: str(uuid)}}

@endpoint GET /rest/api/3/project/recent
@optional {expand: str, properties: [map]}
@returns(200)
@errors {400, 401}

@endpoint GET /rest/api/3/project/search
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, orderBy: str(category/-category/+category/key/-key/+key/name/-name/+name/owner/-owner/+owner/issueCount/-issueCount/+issueCount/lastIssueUpdatedDate/-lastIssueUpdatedDate/+lastIssueUpdatedDate/archivedDate/+archivedDate/-archivedDate/deletedDate/+deletedDate/-deletedDate)=key, id: [int(int64)], keys: [str], query: str, typeKey: str, categoryId: int(int64), action: str(view/browse/edit/create)=view, expand: str, status: [str], properties: [map], propertyQuery: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/project/type
@returns(200)
@errors {401}

@endpoint GET /rest/api/3/project/type/accessible
@returns(200)

@endpoint GET /rest/api/3/project/type/{projectTypeKey}
@required {projectTypeKey: str(software/service_desk/business/product_discovery)}
@returns(200) {color: str, descriptionI18nKey: str, formattedKey: str, icon: str, key: str}
@errors {401, 404}

@endpoint GET /rest/api/3/project/type/{projectTypeKey}/accessible
@required {projectTypeKey: str(software/service_desk/business/product_discovery)}
@returns(200) {color: str, descriptionI18nKey: str, formattedKey: str, icon: str, key: str}
@errors {401, 404}

@endpoint DELETE /rest/api/3/project/{projectIdOrKey}
@required {projectIdOrKey: str}
@optional {enableUndo: bool=true}
@returns(204)
@errors {401, 404}

@endpoint GET /rest/api/3/project/{projectIdOrKey}
@required {projectIdOrKey: str}
@optional {expand: str, properties: [str]}
@returns(200) {archived: bool, archivedBy: any, archivedDate: str(date-time), assigneeType: str, avatarUrls: any, components: [map], deleted: bool, deletedBy: any, deletedDate: str(date-time), description: str, email: str, expand: str, favourite: bool, id: str, insight: any, isPrivate: bool, issueTypeHierarchy: any, issueTypes: [map], key: str, landingPageInfo: any, lead: any, name: str, permissions: any, projectCategory: any, projectTypeKey: str, properties: map, retentionTillDate: str(date-time), roles: map, self: str(uri), simplified: bool, style: str, url: str, uuid: str(uuid), versions: [map]}
@errors {401, 404}

@endpoint PUT /rest/api/3/project/{projectIdOrKey}
@required {projectIdOrKey: str}
@optional {expand: str, assigneeType: str(PROJECT_LEAD/UNASSIGNED), avatarId: int(int64), categoryId: int(int64), description: str, issueSecurityScheme: int(int64), key: str, lead: str, leadAccountId: str, name: str, notificationScheme: int(int64), permissionScheme: int(int64), releasedProjectKeys: [str], url: str}
@returns(200) {archived: bool, archivedBy: any, archivedDate: str(date-time), assigneeType: str, avatarUrls: any, components: [map], deleted: bool, deletedBy: any, deletedDate: str(date-time), description: str, email: str, expand: str, favourite: bool, id: str, insight: any, isPrivate: bool, issueTypeHierarchy: any, issueTypes: [map], key: str, landingPageInfo: any, lead: any, name: str, permissions: any, projectCategory: any, projectTypeKey: str, properties: map, retentionTillDate: str(date-time), roles: map, self: str(uri), simplified: bool, style: str, url: str, uuid: str(uuid), versions: [map]}
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/project/{projectIdOrKey}/archive
@required {projectIdOrKey: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/project/{projectIdOrKey}/avatar
@required {projectIdOrKey: str, id: str}
@optional {fileName: str, isDeletable: bool, isSelected: bool, isSystemAvatar: bool, owner: str, urls: map}
@returns(204)
@errors {401, 403, 404}

@endpoint DELETE /rest/api/3/project/{projectIdOrKey}/avatar/{id}
@required {projectIdOrKey: str, id: int(int64)}
@returns(204)
@errors {401, 403, 404}

@endpoint POST /rest/api/3/project/{projectIdOrKey}/avatar2
@required {projectIdOrKey: str}
@optional {x: int(int32)=0, y: int(int32)=0, size: int(int32)=0}
@returns(201) {fileName: str, id: str, isDeletable: bool, isSelected: bool, isSystemAvatar: bool, owner: str, urls: map}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/project/{projectIdOrKey}/avatars
@required {projectIdOrKey: str}
@returns(200) {custom: [map], system: [map]}
@errors {401, 404}

@endpoint GET /rest/api/3/project/{projectIdOrKey}/classification-config
@required {projectIdOrKey: str}
@returns(200)
@errors {401, 404}

@endpoint DELETE /rest/api/3/project/{projectIdOrKey}/classification-level/default
@required {projectIdOrKey: str}
@returns(204)
@errors {400, 401, 404}

@endpoint GET /rest/api/3/project/{projectIdOrKey}/classification-level/default
@required {projectIdOrKey: str}
@returns(200)
@errors {401, 404}

@endpoint PUT /rest/api/3/project/{projectIdOrKey}/classification-level/default
@required {projectIdOrKey: str, id: str}
@returns(204)
@errors {400, 401, 404}

@endpoint GET /rest/api/3/project/{projectIdOrKey}/component
@required {projectIdOrKey: str}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, orderBy: str(description/-description/+description/issueCount/-issueCount/+issueCount/lead/-lead/+lead/name/-name/+name), componentSource: str(jira/compass/auto)=jira, query: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 404}

@endpoint GET /rest/api/3/project/{projectIdOrKey}/components
@required {projectIdOrKey: str}
@optional {componentSource: str(jira/compass/auto)=jira}
@returns(200)
@errors {401, 404}

@endpoint POST /rest/api/3/project/{projectIdOrKey}/delete
@required {projectIdOrKey: str}
@errors {303, 400, 401, 404}

@endpoint GET /rest/api/3/project/{projectIdOrKey}/features
@required {projectIdOrKey: str}
@returns(200) {features: [map]}
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/project/{projectIdOrKey}/features/{featureKey}
@required {projectIdOrKey: str, featureKey: str}
@optional {state: str(ENABLED/DISABLED/COMING_SOON)}
@returns(200) {features: [map]}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/project/{projectIdOrKey}/properties
@required {projectIdOrKey: str}
@returns(200) {keys: [map]}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/project/{projectIdOrKey}/properties/{propertyKey}
@required {projectIdOrKey: str, propertyKey: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/project/{projectIdOrKey}/properties/{propertyKey}
@required {projectIdOrKey: str, propertyKey: str}
@returns(200) {key: str, value: any}
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/project/{projectIdOrKey}/properties/{propertyKey}
@required {projectIdOrKey: str, propertyKey: str}
@returns(200)
@returns(201)
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/project/{projectIdOrKey}/restore
@required {projectIdOrKey: str}
@returns(200) {archived: bool, archivedBy: any, archivedDate: str(date-time), assigneeType: str, avatarUrls: any, components: [map], deleted: bool, deletedBy: any, deletedDate: str(date-time), description: str, email: str, expand: str, favourite: bool, id: str, insight: any, isPrivate: bool, issueTypeHierarchy: any, issueTypes: [map], key: str, landingPageInfo: any, lead: any, name: str, permissions: any, projectCategory: any, projectTypeKey: str, properties: map, retentionTillDate: str(date-time), roles: map, self: str(uri), simplified: bool, style: str, url: str, uuid: str(uuid), versions: [map]}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/project/{projectIdOrKey}/role
@required {projectIdOrKey: str}
@returns(200)
@errors {401, 404}

@endpoint DELETE /rest/api/3/project/{projectIdOrKey}/role/{id}
@required {projectIdOrKey: str, id: int(int64)}
@optional {user: str, group: str, groupId: str}
@returns(204)
@errors {400, 404}

@endpoint GET /rest/api/3/project/{projectIdOrKey}/role/{id}
@required {projectIdOrKey: str, id: int(int64)}
@optional {excludeInactiveUsers: bool=false}
@returns(200) {actors: [map], admin: bool, currentUserRole: bool, default: bool, description: str, id: int(int64), name: str, roleConfigurable: bool, scope: any, self: str(uri), translatedName: str}
@errors {400, 401, 404}

@endpoint POST /rest/api/3/project/{projectIdOrKey}/role/{id}
@required {projectIdOrKey: str, id: int(int64)}
@optional {group: [str], groupId: [str], user: [str]}
@returns(200) {actors: [map], admin: bool, currentUserRole: bool, default: bool, description: str, id: int(int64), name: str, roleConfigurable: bool, scope: any, self: str(uri), translatedName: str}
@errors {400, 401, 404}

@endpoint PUT /rest/api/3/project/{projectIdOrKey}/role/{id}
@required {projectIdOrKey: str, id: int(int64)}
@optional {categorisedActors: map, id: int(int64)}
@returns(200) {actors: [map], admin: bool, currentUserRole: bool, default: bool, description: str, id: int(int64), name: str, roleConfigurable: bool, scope: any, self: str(uri), translatedName: str}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/project/{projectIdOrKey}/roledetails
@required {projectIdOrKey: str}
@optional {currentMember: bool=false, excludeConnectAddons: bool=false, excludeOtherServiceRoles: bool=false}
@returns(200)
@errors {401, 404}

@endpoint GET /rest/api/3/project/{projectIdOrKey}/statuses
@required {projectIdOrKey: str}
@returns(200)
@errors {401, 404}

@endpoint GET /rest/api/3/project/{projectIdOrKey}/version
@required {projectIdOrKey: str}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, orderBy: str(description/-description/+description/name/-name/+name/releaseDate/-releaseDate/+releaseDate/sequence/-sequence/+sequence/startDate/-startDate/+startDate), query: str, status: str, expand: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {404}

@endpoint GET /rest/api/3/project/{projectIdOrKey}/versions
@required {projectIdOrKey: str}
@optional {expand: str}
@returns(200)
@errors {404}

@endpoint GET /rest/api/3/project/{projectId}/email
@required {projectId: int(int64)}
@returns(200) {emailAddress: str, emailAddressStatus: [str]}
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/project/{projectId}/email
@required {projectId: int(int64)}
@optional {emailAddress: str, emailAddressStatus: [str]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/project/{projectId}/hierarchy
@required {projectId: int(int64)}
@returns(200) {hierarchy: [map], projectId: int(int64)}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/project/{projectKeyOrId}/issuesecuritylevelscheme
@required {projectKeyOrId: str}
@returns(200) {defaultSecurityLevelId: int(int64), description: str, id: int(int64), levels: [map], name: str, self: str}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/project/{projectKeyOrId}/notificationscheme
@required {projectKeyOrId: str}
@optional {expand: str}
@returns(200) {description: str, expand: str, id: int(int64), name: str, notificationSchemeEvents: [map], projects: [int(int64)], scope: any, self: str}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/project/{projectKeyOrId}/permissionscheme
@required {projectKeyOrId: str}
@optional {expand: str}
@returns(200) {description: str, expand: str, id: int(int64), name: str, permissions: [map], scope: any, self: str(uri)}
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/project/{projectKeyOrId}/permissionscheme
@required {projectKeyOrId: str, id: int(int64)}
@optional {expand: str}
@returns(200) {description: str, expand: str, id: int(int64), name: str, permissions: [map], scope: any, self: str(uri)}
@errors {401, 403, 404}

@endpoint GET /rest/api/3/project/{projectKeyOrId}/securitylevel
@required {projectKeyOrId: str}
@returns(200) {levels: [map]}
@errors {404}

@endpoint GET /rest/api/3/projectCategory
@returns(200)
@errors {401}

@endpoint POST /rest/api/3/projectCategory
@optional {description: str, id: str, name: str, self: str(uri)}
@returns(201) {description: str, id: str, name: str, self: str(uri)}
@errors {400, 401, 403, 409}

@endpoint DELETE /rest/api/3/projectCategory/{id}
@required {id: int(int64)}
@returns(204)
@errors {401, 403, 404}

@endpoint GET /rest/api/3/projectCategory/{id}
@required {id: int(int64)}
@returns(200) {description: str, id: str, name: str, self: str(uri)}
@errors {401, 404}

@endpoint PUT /rest/api/3/projectCategory/{id}
@required {id: int(int64)}
@optional {description: str, id: str, name: str, self: str(uri)}
@returns(200) {description: str, id: str, name: str, self: str}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/projects/fields
@required {projectId: [int(int64)], workTypeId: [int(int64)]}
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, fieldId: [str]}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/projectvalidate/key
@optional {key: str}
@returns(200) {errorMessages: [str], errors: map, status: int(int32)}
@errors {401}

@endpoint GET /rest/api/3/projectvalidate/validProjectKey
@optional {key: str}
@returns(200)
@errors {401}

@endpoint GET /rest/api/3/projectvalidate/validProjectName
@required {name: str}
@returns(200)
@errors {400, 401, 404}

@endpoint POST /rest/api/3/redact
@optional {redactions: [map{contentItem!: map, externalId!: str(uuid), reason!: str, redactionPosition!: map}]}
@returns(202)
@errors {400, 401, 403}

@endpoint GET /rest/api/3/redact/status/{jobId}
@required {jobId: str}
@returns(200) {bulkRedactionResponse: map{results: [map]}, jobStatus: str}
@errors {403, 404}

@endpoint GET /rest/api/3/resolution
@returns(200)
@errors {401}

@endpoint POST /rest/api/3/resolution
@required {name: str}
@optional {description: str}
@returns(201) {id: str}
@errors {400, 401, 403}

@endpoint PUT /rest/api/3/resolution/default
@required {id: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/resolution/move
@required {ids: [str]}
@optional {after: str, position: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/resolution/search
@optional {startAt: str=0, maxResults: str=50, id: [str], onlyDefault: bool=false}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401}

@endpoint DELETE /rest/api/3/resolution/{id}
@required {id: str, replaceWith: str=}
@errors {303, 400, 401, 403, 404, 409}

@endpoint GET /rest/api/3/resolution/{id}
@required {id: str}
@returns(200) {description: str, id: str, name: str, self: str(uri)}
@errors {401, 404}

@endpoint PUT /rest/api/3/resolution/{id}
@required {id: str, name: str}
@optional {description: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/role
@returns(200)
@errors {401, 403}

@endpoint POST /rest/api/3/role
@optional {description: str, name: str}
@returns(200) {actors: [map], admin: bool, currentUserRole: bool, default: bool, description: str, id: int(int64), name: str, roleConfigurable: bool, scope: any, self: str(uri), translatedName: str}
@errors {400, 401, 403, 409}

@endpoint DELETE /rest/api/3/role/{id}
@required {id: int(int64)}
@optional {swap: int(int64)}
@returns(204)
@errors {400, 401, 403, 404, 409}

@endpoint GET /rest/api/3/role/{id}
@required {id: int(int64)}
@returns(200) {actors: [map], admin: bool, currentUserRole: bool, default: bool, description: str, id: int(int64), name: str, roleConfigurable: bool, scope: any, self: str(uri), translatedName: str}
@errors {401, 403, 404}

@endpoint POST /rest/api/3/role/{id}
@required {id: int(int64)}
@optional {description: str, name: str}
@returns(200) {actors: [map], admin: bool, currentUserRole: bool, default: bool, description: str, id: int(int64), name: str, roleConfigurable: bool, scope: any, self: str(uri), translatedName: str}
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/role/{id}
@required {id: int(int64)}
@optional {description: str, name: str}
@returns(200) {actors: [map], admin: bool, currentUserRole: bool, default: bool, description: str, id: int(int64), name: str, roleConfigurable: bool, scope: any, self: str(uri), translatedName: str}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/role/{id}/actors
@required {id: int(int64)}
@optional {user: str, groupId: str, group: str}
@returns(200) {actors: [map], admin: bool, currentUserRole: bool, default: bool, description: str, id: int(int64), name: str, roleConfigurable: bool, scope: any, self: str(uri), translatedName: str}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/role/{id}/actors
@required {id: int(int64)}
@returns(200) {actors: [map], admin: bool, currentUserRole: bool, default: bool, description: str, id: int(int64), name: str, roleConfigurable: bool, scope: any, self: str(uri), translatedName: str}
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/role/{id}/actors
@required {id: int(int64)}
@optional {group: [str], groupId: [str], user: [str]}
@returns(200) {actors: [map], admin: bool, currentUserRole: bool, default: bool, description: str, id: int(int64), name: str, roleConfigurable: bool, scope: any, self: str(uri), translatedName: str}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/screens
@optional {startAt: int(int64)=0, maxResults: int(int32)=100, id: [int(int64)], queryString: str=, scope: [str], orderBy: str(name/-name/+name/id/-id/+id)}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 403}

@endpoint POST /rest/api/3/screens
@required {name: str}
@optional {description: str}
@returns(201) {description: str, id: int(int64), name: str, scope: any}
@errors {400, 401, 403}

@endpoint POST /rest/api/3/screens/addToDefault/{fieldId}
@required {fieldId: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/screens/tabs
@optional {screenId: [int(int64)], tabId: [int(int64)], startAt: int(int64)=0, maxResult: int(int32)=100}
@returns(200)
@errors {400, 401, 403}

@endpoint DELETE /rest/api/3/screens/{screenId}
@required {screenId: int(int64)}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/screens/{screenId}
@required {screenId: int(int64)}
@optional {description: str, name: str}
@returns(200) {description: str, id: int(int64), name: str, scope: any}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/screens/{screenId}/availableFields
@required {screenId: int(int64)}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /rest/api/3/screens/{screenId}/tabs
@required {screenId: int(int64)}
@optional {projectKey: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/screens/{screenId}/tabs
@required {screenId: int(int64), name: str}
@optional {id: int(int64)}
@returns(200) {id: int(int64), name: str}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/screens/{screenId}/tabs/{tabId}
@required {screenId: int(int64), tabId: int(int64)}
@returns(204)
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/screens/{screenId}/tabs/{tabId}
@required {screenId: int(int64), tabId: int(int64), name: str}
@optional {id: int(int64)}
@returns(200) {id: int(int64), name: str}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/screens/{screenId}/tabs/{tabId}/fields
@required {screenId: int(int64), tabId: int(int64)}
@optional {projectKey: str}
@returns(200)
@errors {401, 403, 404}

@endpoint POST /rest/api/3/screens/{screenId}/tabs/{tabId}/fields
@required {screenId: int(int64), tabId: int(int64), fieldId: str}
@returns(200) {id: str, name: str}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/screens/{screenId}/tabs/{tabId}/fields/{id}
@required {screenId: int(int64), tabId: int(int64), id: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/screens/{screenId}/tabs/{tabId}/fields/{id}/move
@required {screenId: int(int64), tabId: int(int64), id: str}
@optional {after: str(uri), position: str(Earlier/Later/First/Last)}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/screens/{screenId}/tabs/{tabId}/move/{pos}
@required {screenId: int(int64), tabId: int(int64), pos: int(int32)}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/screenscheme
@optional {startAt: int(int64)=0, maxResults: int(int32)=25, id: [int(int64)], expand: str=, queryString: str=, orderBy: str(name/-name/+name/id/-id/+id)}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 403}

@endpoint POST /rest/api/3/screenscheme
@required {name: str, screens: any}
@optional {description: str}
@returns(201) {id: int(int64)}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/screenscheme/{screenSchemeId}
@required {screenSchemeId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/screenscheme/{screenSchemeId}
@required {screenSchemeId: str}
@optional {description: str, name: str, screens: any}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/search
@optional {jql: str, startAt: int(int32)=0, maxResults: int(int32)=50, validateQuery: str(strict/warn/none/true/false)=strict, fields: [str], expand: str, properties: [str], fieldsByKeys: bool=false, failFast: bool=false}
@returns(200) {expand: str, issues: [map], maxResults: int(int32), names: map, schema: map, startAt: int(int32), total: int(int32), warningMessages: [str]}
@errors {400, 401}

@endpoint POST /rest/api/3/search
@optional {expand: [str], fields: [str], fieldsByKeys: bool, jql: str, maxResults: int(int32)=50, properties: [str], startAt: int(int32), validateQuery: str(strict/warn/none/true/false)}
@returns(200) {expand: str, issues: [map], maxResults: int(int32), names: map, schema: map, startAt: int(int32), total: int(int32), warningMessages: [str]}
@errors {400, 401}

@endpoint POST /rest/api/3/search/approximate-count
@optional {jql: str}
@returns(200) {count: int(int64)}
@errors {400, 401}

@endpoint GET /rest/api/3/search/jql
@optional {jql: str, nextPageToken: str, maxResults: int(int32)=50, fields: [str], expand: str, properties: [str], fieldsByKeys: bool=false, failFast: bool=false, reconcileIssues: [int(int64)]}
@returns(200) {isLast: bool, issues: [map], names: map, nextPageToken: str, schema: map}
@errors {400, 401}

@endpoint POST /rest/api/3/search/jql
@optional {expand: str, fields: [str], fieldsByKeys: bool, jql: str, maxResults: int(int32)=50, nextPageToken: str, properties: [str], reconcileIssues: [int(int64)]}
@returns(200) {isLast: bool, issues: [map], names: map, nextPageToken: str, schema: map}
@errors {400, 401}

@endpoint GET /rest/api/3/securitylevel/{id}
@required {id: str}
@returns(200) {description: str, id: str, isDefault: bool, issueSecuritySchemeId: str, name: str, self: str}
@errors {401, 404}

@endpoint GET /rest/api/3/serverInfo
@returns(200) {baseUrl: str, buildDate: str(date-time), buildNumber: int(int32), deploymentType: str, displayUrl: str, displayUrlConfluence: str, displayUrlServicedeskHelpCenter: str, healthChecks: [map], scmInfo: str, serverTime: str(date-time), serverTimeZone: str, serverTitle: str, version: str, versionNumbers: [int(int32)]}
@errors {401}

@endpoint GET /rest/api/3/settings/columns
@returns(200)
@errors {401, 403}

@endpoint PUT /rest/api/3/settings/columns
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/status
@returns(200)
@errors {401}

@endpoint GET /rest/api/3/status/{idOrName}
@required {idOrName: str}
@returns(200) {description: str, iconUrl: str, id: str, name: str, scope: any, self: str, statusCategory: any}
@errors {401, 404}

@endpoint GET /rest/api/3/statuscategory
@returns(200)
@errors {401}

@endpoint GET /rest/api/3/statuscategory/{idOrKey}
@required {idOrKey: str}
@returns(200) {colorName: str, id: int(int64), key: str, name: str, self: str}
@errors {401, 404}

@endpoint DELETE /rest/api/3/statuses
@required {id: [str]}
@returns(204)
@errors {400, 401}

@endpoint GET /rest/api/3/statuses
@required {id: [str]}
@returns(200)
@errors {400, 401}

@endpoint POST /rest/api/3/statuses
@required {scope: map{project: map, type!: str}, statuses: [map{description: str, name!: str, statusCategory!: str}]}
@returns(200)
@errors {400, 401, 409}

@endpoint PUT /rest/api/3/statuses
@required {statuses: [map{description: str, id!: str, name!: str, statusCategory!: str}]}
@returns(204)
@errors {400, 401, 409}

@endpoint GET /rest/api/3/statuses/byNames
@required {name: [str]}
@optional {projectId: str}
@returns(200)
@errors {400, 401}

@endpoint GET /rest/api/3/statuses/search
@optional {projectId: str, startAt: int(int64)=0, maxResults: int(int32)=200, searchString: str, statusCategory: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str, self: str, startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/statuses/{statusId}/project/{projectId}/issueTypeUsages
@required {statusId: str, projectId: str}
@optional {nextPageToken: str, maxResults: int(int32)=50}
@returns(200) {issueTypes: map{nextPageToken: str, values: [map]}, projectId: str, statusId: str}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/statuses/{statusId}/projectUsages
@required {statusId: str}
@optional {nextPageToken: str, maxResults: int(int32)=50}
@returns(200) {projects: map{nextPageToken: str, values: [map]}, statusId: str}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/statuses/{statusId}/workflowUsages
@required {statusId: str}
@optional {nextPageToken: str, maxResults: int(int32)=50}
@returns(200) {statusId: str, workflows: map{nextPageToken: str, values: [map]}}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/task/{taskId}
@required {taskId: str}
@returns(200) {description: str, elapsedRuntime: int(int64), finished: int(int64), id: str, lastUpdate: int(int64), message: str, progress: int(int64), result: any, self: str(uri), started: int(int64), status: str, submitted: int(int64), submittedBy: int(int64)}
@errors {401, 403, 404}

@endpoint POST /rest/api/3/task/{taskId}/cancel
@required {taskId: str}
@returns(202)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/uiModifications
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, expand: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403}

@endpoint POST /rest/api/3/uiModifications
@required {name: str}
@optional {contexts: [map{id: str, isAvailable: bool, issueTypeId: str, portalId: str, projectId: str, requestTypeId: str, viewType: str}], data: str, description: str}
@returns(201) {id: str, self: str}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/uiModifications/{uiModificationId}
@required {uiModificationId: str}
@returns(204)
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/uiModifications/{uiModificationId}
@required {uiModificationId: str}
@optional {contexts: [map{id: str, isAvailable: bool, issueTypeId: str, portalId: str, projectId: str, requestTypeId: str, viewType: str}], data: str, description: str, name: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/universal_avatar/type/{type}/owner/{entityId}
@required {type: str(project/issuetype/priority), entityId: str}
@returns(200) {custom: [map], system: [map]}
@errors {401, 404}

@endpoint POST /rest/api/3/universal_avatar/type/{type}/owner/{entityId}
@required {type: str(project/issuetype/priority), entityId: str, size: int(int32)=0}
@optional {x: int(int32)=0, y: int(int32)=0}
@returns(201) {fileName: str, id: str, isDeletable: bool, isSelected: bool, isSystemAvatar: bool, owner: str, urls: map}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/universal_avatar/type/{type}/owner/{owningObjectId}/avatar/{id}
@required {type: str(project/issuetype/priority), owningObjectId: str, id: int(int64)}
@returns(204)
@errors {400, 403, 404}

@endpoint GET /rest/api/3/universal_avatar/view/type/{type}
@required {type: str(issuetype/project/priority)}
@optional {size: str(xsmall/small/medium/large/xlarge), format: str(png/svg)}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /rest/api/3/universal_avatar/view/type/{type}/avatar/{id}
@required {type: str(issuetype/project/priority), id: int(int64)}
@optional {size: str(xsmall/small/medium/large/xlarge), format: str(png/svg)}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/universal_avatar/view/type/{type}/owner/{entityId}
@required {type: str(issuetype/project/priority), entityId: str}
@optional {size: str(xsmall/small/medium/large/xlarge), format: str(png/svg)}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/user
@required {accountId: str}
@optional {username: str, key: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/user
@optional {accountId: str, username: str, key: str, expand: str}
@returns(200) {accountId: str, accountType: str, active: bool, appType: str, applicationRoles: any, avatarUrls: any, displayName: str, emailAddress: str, expand: str, groups: any, guest: bool, key: str, locale: str, name: str, self: str(uri), timeZone: str}
@errors {401, 403, 404}

@endpoint POST /rest/api/3/user
@required {emailAddress: str, products: [str]}
@optional {applicationKeys: [str], displayName: str, key: str, name: str, password: str, self: str}
@returns(201) {accountId: str, accountType: str, active: bool, appType: str, applicationRoles: any, avatarUrls: any, displayName: str, emailAddress: str, expand: str, groups: any, guest: bool, key: str, locale: str, name: str, self: str(uri), timeZone: str}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/user/assignable/multiProjectSearch
@required {projectKeys: str}
@optional {query: str, username: str, accountId: str, startAt: int(int32)=0, maxResults: int(int32)=50}
@returns(200)
@errors {400, 401, 404, 429}

@endpoint GET /rest/api/3/user/assignable/search
@optional {query: str, sessionId: str, username: str, accountId: str, project: str, issueKey: str, issueId: str, startAt: int(int32)=0, maxResults: int(int32)=50, actionDescriptorId: int(int32), recommend: bool=false, accountType: [str], appType: [str]}
@returns(200)
@errors {400, 401, 404, 429}

@endpoint GET /rest/api/3/user/bulk
@required {accountId: [str]}
@optional {startAt: int(int64)=0, maxResults: int(int32)=10, username: [str], key: [str]}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/user/bulk/migration
@optional {startAt: int(int64)=0, maxResults: int(int32)=10, username: [str], key: [str]}
@returns(200)
@errors {400, 401}

@endpoint DELETE /rest/api/3/user/columns
@optional {accountId: str, username: str}
@returns(204)
@errors {401, 403}

@endpoint GET /rest/api/3/user/columns
@optional {accountId: str, username: str}
@returns(200)
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/user/columns
@optional {accountId: str}
@returns(200)
@errors {401, 403, 404, 429, 500}

@endpoint GET /rest/api/3/user/email
@required {accountId: str}
@returns(200) {accountId: str, email: str}
@errors {400, 401, 404, 503}

@endpoint GET /rest/api/3/user/email/bulk
@required {accountId: [str]}
@returns(200) {accountId: str, email: str}
@errors {400, 401, 503}

@endpoint GET /rest/api/3/user/groups
@required {accountId: str}
@optional {username: str, key: str}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /rest/api/3/user/permission/search
@required {permissions: str}
@optional {query: str, username: str, accountId: str, issueKey: str, projectKey: str, startAt: int(int32)=0, maxResults: int(int32)=50}
@returns(200)
@errors {400, 401, 403, 404, 429}

@endpoint GET /rest/api/3/user/picker
@required {query: str}
@optional {maxResults: int(int32)=50, showAvatar: bool=false, exclude: [str], excludeAccountIds: [str], avatarSize: str, excludeConnectUsers: bool=false}
@returns(200) {header: str, total: int(int32), users: [map]}
@errors {400, 401, 429}

@endpoint GET /rest/api/3/user/properties
@optional {accountId: str, userKey: str, username: str}
@returns(200) {keys: [map]}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/user/properties/{propertyKey}
@required {propertyKey: str}
@optional {accountId: str, userKey: str, username: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/user/properties/{propertyKey}
@required {propertyKey: str}
@optional {accountId: str, userKey: str, username: str}
@returns(200) {key: str, value: any}
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/user/properties/{propertyKey}
@required {propertyKey: str}
@optional {accountId: str, userKey: str, username: str}
@returns(200)
@returns(201)
@errors {400, 401, 403, 404, 405}

@endpoint GET /rest/api/3/user/search
@optional {query: str, username: str, accountId: str, startAt: int(int32)=0, maxResults: int(int32)=50, property: str}
@returns(200)
@errors {400, 401, 429}

@endpoint GET /rest/api/3/user/search/query
@required {query: str}
@optional {startAt: int(int64)=0, maxResults: int(int32)=100}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 408}

@endpoint GET /rest/api/3/user/search/query/key
@required {query: str}
@optional {startAt: int(int64)=0, maxResult: int(int32)=100}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 401, 403, 408}

@endpoint GET /rest/api/3/user/viewissue/search
@optional {query: str, username: str, accountId: str, issueKey: str, projectKey: str, startAt: int(int32)=0, maxResults: int(int32)=50}
@returns(200)
@errors {400, 401, 404, 429}

@endpoint GET /rest/api/3/users
@optional {startAt: int(int32)=0, maxResults: int(int32)=50, expand: str}
@returns(200)
@errors {400, 403, 409}

@endpoint GET /rest/api/3/users/search
@optional {startAt: int(int32)=0, maxResults: int(int32)=50, expand: str}
@returns(200)
@errors {400, 403, 409}

@endpoint POST /rest/api/3/version
@optional {approvers: [map{accountId: str, declineReason: str, description: str, status: str}], archived: bool, description: str, driver: str, expand: str, id: str, issuesStatusForFixVersion: any, moveUnfixedIssuesTo: str(uri), name: str, operations: [map{href: str, iconClass: str, id: str, label: str, styleClass: str, title: str, weight: int(int32)}], overdue: bool, project: str, projectId: int(int64), releaseDate: str(date), released: bool, self: str(uri), startDate: str(date), userReleaseDate: str, userStartDate: str}
@returns(201) {approvers: [map], archived: bool, description: str, driver: str, expand: str, id: str, issuesStatusForFixVersion: any, moveUnfixedIssuesTo: str(uri), name: str, operations: [map], overdue: bool, project: str, projectId: int(int64), releaseDate: str(date), released: bool, self: str(uri), startDate: str(date), userReleaseDate: str, userStartDate: str}
@errors {400, 401, 404}

@endpoint DELETE /rest/api/3/version/{id}
@required {id: str}
@optional {moveFixIssuesTo: str, moveAffectedIssuesTo: str}
@returns(204)
@errors {400, 401, 404}

@endpoint GET /rest/api/3/version/{id}
@required {id: str}
@optional {expand: str}
@returns(200) {approvers: [map], archived: bool, description: str, driver: str, expand: str, id: str, issuesStatusForFixVersion: any, moveUnfixedIssuesTo: str(uri), name: str, operations: [map], overdue: bool, project: str, projectId: int(int64), releaseDate: str(date), released: bool, self: str(uri), startDate: str(date), userReleaseDate: str, userStartDate: str}
@errors {401, 404}

@endpoint PUT /rest/api/3/version/{id}
@required {id: str}
@optional {approvers: [map{accountId: str, declineReason: str, description: str, status: str}], archived: bool, description: str, driver: str, expand: str, id: str, issuesStatusForFixVersion: any, moveUnfixedIssuesTo: str(uri), name: str, operations: [map{href: str, iconClass: str, id: str, label: str, styleClass: str, title: str, weight: int(int32)}], overdue: bool, project: str, projectId: int(int64), releaseDate: str(date), released: bool, self: str(uri), startDate: str(date), userReleaseDate: str, userStartDate: str}
@returns(200) {approvers: [map], archived: bool, description: str, driver: str, expand: str, id: str, issuesStatusForFixVersion: any, moveUnfixedIssuesTo: str(uri), name: str, operations: [map], overdue: bool, project: str, projectId: int(int64), releaseDate: str(date), released: bool, self: str(uri), startDate: str(date), userReleaseDate: str, userStartDate: str}
@errors {400, 401, 404}

@endpoint PUT /rest/api/3/version/{id}/mergeto/{moveIssuesTo}
@required {id: str, moveIssuesTo: str}
@returns(204)
@errors {400, 401, 404}

@endpoint POST /rest/api/3/version/{id}/move
@required {id: str}
@optional {after: str(uri), position: str(Earlier/Later/First/Last)}
@returns(200) {approvers: [map], archived: bool, description: str, driver: str, expand: str, id: str, issuesStatusForFixVersion: any, moveUnfixedIssuesTo: str(uri), name: str, operations: [map], overdue: bool, project: str, projectId: int(int64), releaseDate: str(date), released: bool, self: str(uri), startDate: str(date), userReleaseDate: str, userStartDate: str}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/version/{id}/relatedIssueCounts
@required {id: str}
@returns(200) {customFieldUsage: [map], issueCountWithCustomFieldsShowingVersion: int(int64), issuesAffectedCount: int(int64), issuesFixedCount: int(int64), self: str(uri)}
@errors {401, 404}

@endpoint GET /rest/api/3/version/{id}/relatedwork
@required {id: str}
@returns(200)
@errors {401, 404, 500}

@endpoint POST /rest/api/3/version/{id}/relatedwork
@required {id: str, category: str}
@optional {issueId: int(int64), relatedWorkId: str, title: str, url: str(uri)}
@returns(201) {category: str, issueId: int(int64), relatedWorkId: str, title: str, url: str(uri)}
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/version/{id}/relatedwork
@required {id: str, category: str}
@optional {issueId: int(int64), relatedWorkId: str, title: str, url: str(uri)}
@returns(200) {category: str, issueId: int(int64), relatedWorkId: str, title: str, url: str(uri)}
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/version/{id}/removeAndSwap
@required {id: str}
@optional {customFieldReplacementList: [map{customFieldId: int(int64), moveTo: int(int64)}], moveAffectedIssuesTo: int(int64), moveFixIssuesTo: int(int64)}
@returns(204)
@errors {400, 401, 404}

@endpoint GET /rest/api/3/version/{id}/unresolvedIssueCount
@required {id: str}
@returns(200) {issuesCount: int(int64), issuesUnresolvedCount: int(int64), self: str(uri)}
@errors {401, 404}

@endpoint DELETE /rest/api/3/version/{versionId}/relatedwork/{relatedWorkId}
@required {versionId: str, relatedWorkId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/webhook
@required {webhookIds: [int(int64)]}
@returns(202)
@errors {400, 403}

@endpoint GET /rest/api/3/webhook
@optional {startAt: int(int64)=0, maxResults: int(int32)=100}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 403}

@endpoint POST /rest/api/3/webhook
@required {url: str, webhooks: [map{events!: [str], fieldIdsFilter: [str], issuePropertyKeysFilter: [str], jqlFilter!: str}]}
@returns(200) {webhookRegistrationResult: [map]}
@errors {400, 403}

@endpoint GET /rest/api/3/webhook/failed
@optional {maxResults: int(int32), after: int(int64)}
@returns(200) {maxResults: int(int32), next: str(uri), values: [map]}
@errors {400, 403}

@endpoint PUT /rest/api/3/webhook/refresh
@required {webhookIds: [int(int64)]}
@returns(200) {expirationDate: int(int64)}
@errors {400, 403}

@endpoint GET /rest/api/3/workflow
@optional {workflowName: str}
@returns(200)
@errors {401}

@endpoint POST /rest/api/3/workflow
@required {name: str, statuses: [map{id!: str, properties: map}], transitions: [map{description: str, from: [str], name!: str, properties: map, rules: any, screen: any, to!: str, type!: str}]}
@optional {description: str}
@returns(201) {entityId: str, name: str}
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/workflow/history
@optional {version: int(int64), workflowId: str}
@returns(200) {statuses: [map], workflows: [map]}
@errors {400, 401}

@endpoint POST /rest/api/3/workflow/history/list
@optional {expand: str, workflowId: str}
@returns(200) {entries: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/workflow/rule/config
@required {types: [str]}
@optional {startAt: int(int64)=0, maxResults: int(int32)=10, keys: [str], workflowNames: [str], withTags: [str], draft: bool, expand: str}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {400, 403, 404, 503}

@endpoint PUT /rest/api/3/workflow/rule/config
@required {workflows: [map{conditions: [map], postFunctions: [map], validators: [map], workflowId!: map}]}
@returns(200) {updateResults: [map]}
@errors {400, 403, 503}

@endpoint PUT /rest/api/3/workflow/rule/config/delete
@required {workflows: [map{workflowId!: map, workflowRuleIds!: [str]}]}
@returns(200) {updateResults: [map]}
@errors {400, 403}

@endpoint GET /rest/api/3/workflow/search
@optional {startAt: int(int64)=0, maxResults: int(int32)=50, workflowName: [str], expand: str, queryString: str, orderBy: str(name/-name/+name/created/-created/+created/updated/+updated/-updated), isActive: bool}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 403}

@endpoint DELETE /rest/api/3/workflow/transitions/{transitionId}/properties
@required {transitionId: int(int64), key: str, workflowName: str}
@optional {workflowMode: str(live/draft)}
@returns(200)
@errors {304, 400, 401, 403, 404}

@endpoint GET /rest/api/3/workflow/transitions/{transitionId}/properties
@required {transitionId: int(int64), workflowName: str}
@optional {includeReservedKeys: bool=false, key: str, workflowMode: str(live/draft)=live}
@returns(200) {id: str, key: str, value: str}
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/workflow/transitions/{transitionId}/properties
@required {transitionId: int(int64), key: str, workflowName: str, value: str}
@optional {workflowMode: str(live/draft)=live, id: str, key: str}
@returns(200) {id: str, key: str, value: str}
@errors {400, 401, 403, 404}

@endpoint PUT /rest/api/3/workflow/transitions/{transitionId}/properties
@required {transitionId: int(int64), key: str, workflowName: str, value: str}
@optional {workflowMode: str(live/draft), id: str, key: str}
@returns(200) {id: str, key: str, value: str}
@errors {304, 400, 401, 403, 404}

@endpoint DELETE /rest/api/3/workflow/{entityId}
@required {entityId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/workflow/{workflowId}/project/{projectId}/issueTypeUsages
@required {workflowId: str, projectId: int(int64)}
@optional {nextPageToken: str, maxResults: int(int32)=50}
@returns(200) {issueTypes: map{nextPageToken: str, values: [map]}, projectId: str, workflowId: str}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/workflow/{workflowId}/projectUsages
@required {workflowId: str}
@optional {nextPageToken: str, maxResults: int(int32)=50}
@returns(200) {projects: map{nextPageToken: str, values: [map]}, workflowId: str}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/workflow/{workflowId}/workflowSchemes
@required {workflowId: str}
@optional {nextPageToken: str, maxResults: int(int32)=50}
@returns(200) {workflowId: str, workflowSchemes: map{nextPageToken: str, values: [map]}}
@errors {400, 401, 404}

@endpoint POST /rest/api/3/workflows
@optional {projectAndIssueTypes: [map{issueTypeId!: str, projectId!: str}], workflowIds: [str], workflowNames: [str]}
@returns(200) {statuses: [map], workflows: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/workflows/capabilities
@optional {workflowId: str, projectId: str, issueTypeId: str}
@returns(200) {connectRules: [map], editorScope: str, forgeRules: [map], projectTypes: [str], systemRules: [map], triggerRules: [map]}
@errors {400, 401}

@endpoint POST /rest/api/3/workflows/create
@optional {scope: map{project: map, type: str}, statuses: [map{description: str, id: str, name!: str, statusCategory!: str, statusReference!: str}], workflows: [map{description: str, loopedTransitionContainerLayout: map, name!: str, startPointLayout: map, statuses!: [map], transitions!: [map]}]}
@returns(200) {statuses: [map], workflows: [map]}
@errors {400, 401, 409}

@endpoint POST /rest/api/3/workflows/create/validation
@required {payload: map{scope: map, statuses: [map], workflows: [map]}}
@optional {validationOptions: map{levels: [str]}}
@returns(200) {errors: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/workflows/defaultEditor
@returns(200) {value: str}

@endpoint POST /rest/api/3/workflows/preview
@required {projectId: str}
@optional {issueTypeIds: [str], workflowIds: [str], workflowNames: [str]}
@returns(200) {statuses: [map], workflows: [map]}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/workflows/search
@optional {startAt: int(int64), maxResults: int(int32), expand: str, queryString: str, orderBy: str, scope: str, isActive: bool}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str, self: str, startAt: int(int64), statuses: [map], total: int(int64), values: [map]}
@errors {400, 401}

@endpoint POST /rest/api/3/workflows/update
@optional {statuses: [map{description: str, id: str, name!: str, statusCategory!: str, statusReference!: str}], workflows: [map{defaultStatusMappings: [map], description: str, id!: str, loopedTransitionContainerLayout: map, startPointLayout: map, statusMappings: [map], statuses!: [map], transitions!: [map], version!: map}]}
@returns(200) {statuses: [map], taskId: str?, workflows: [map]}
@errors {400, 401, 409}

@endpoint POST /rest/api/3/workflows/update/validation
@required {payload: map{statuses: [map], workflows: [map]}}
@optional {validationOptions: map{levels: [str]}}
@returns(200) {errors: [map]}
@errors {400, 401}

@endpoint GET /rest/api/3/workflowscheme
@optional {startAt: int(int64)=0, maxResults: int(int32)=50}
@returns(200) {isLast: bool, maxResults: int(int32), nextPage: str(uri), self: str(uri), startAt: int(int64), total: int(int64), values: [map]}
@errors {401, 403}

@endpoint POST /rest/api/3/workflowscheme
@optional {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@returns(201) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {400, 401, 403}

@endpoint GET /rest/api/3/workflowscheme/project
@required {projectId: [int(int64)]}
@returns(200) {values: [map]}
@errors {400, 401, 403}

@endpoint PUT /rest/api/3/workflowscheme/project
@required {projectId: str}
@optional {workflowSchemeId: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/workflowscheme/project/switch
@optional {mappingsByIssueTypeOverride: [map{issueTypeId: str, statusMappings: [map]}], projectId: str, targetSchemeId: str}
@errors {303, 400, 401, 409}

@endpoint POST /rest/api/3/workflowscheme/read
@optional {projectIds: [str], workflowSchemeIds: [str]}
@returns(200)
@errors {400, 401}

@endpoint POST /rest/api/3/workflowscheme/update
@required {description: str, id: str, name: str, version: map{id: str, versionNumber: int(int64)}}
@optional {defaultWorkflowId: str, statusMappingsByIssueTypeOverride: [map{issueTypeId: str, statusMappings: [map]}], statusMappingsByWorkflows: [map{newWorkflowId!: str, oldWorkflowId!: str, statusMappings!: [map]}], workflowsForIssueTypes: [map{issueTypeIds!: [str], workflowId!: str}]}
@returns(200)
@errors {303, 400, 401, 409}

@endpoint POST /rest/api/3/workflowscheme/update/mappings
@required {id: str, workflowsForIssueTypes: [map{issueTypeIds!: [str], workflowId!: str}]}
@optional {defaultWorkflowId: str}
@returns(200) {statusMappingsByIssueTypes: [map], statusMappingsByWorkflows: [map], statuses: [map], statusesPerWorkflow: [map]}
@errors {400, 401}

@endpoint DELETE /rest/api/3/workflowscheme/{id}
@required {id: int(int64)}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/workflowscheme/{id}
@required {id: int(int64)}
@optional {returnDraftIfExists: bool=false}
@returns(200) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/workflowscheme/{id}
@required {id: int(int64)}
@optional {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@returns(200) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/workflowscheme/{id}/createdraft
@required {id: int(int64)}
@returns(201) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {400, 401, 403}

@endpoint DELETE /rest/api/3/workflowscheme/{id}/default
@required {id: int(int64)}
@optional {updateDraftIfNeeded: bool}
@returns(200) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/workflowscheme/{id}/default
@required {id: int(int64)}
@optional {returnDraftIfExists: bool=false}
@returns(200) {updateDraftIfNeeded: bool, workflow: str}
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/workflowscheme/{id}/default
@required {id: int(int64), workflow: str}
@optional {updateDraftIfNeeded: bool}
@returns(200) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/workflowscheme/{id}/draft
@required {id: int(int64)}
@returns(204)
@errors {401, 403, 404}

@endpoint GET /rest/api/3/workflowscheme/{id}/draft
@required {id: int(int64)}
@returns(200) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/workflowscheme/{id}/draft
@required {id: int(int64)}
@optional {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@returns(200) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/workflowscheme/{id}/draft/default
@required {id: int(int64)}
@returns(200) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {401, 403, 404}

@endpoint GET /rest/api/3/workflowscheme/{id}/draft/default
@required {id: int(int64)}
@returns(200) {updateDraftIfNeeded: bool, workflow: str}
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/workflowscheme/{id}/draft/default
@required {id: int(int64), workflow: str}
@optional {updateDraftIfNeeded: bool}
@returns(200) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/workflowscheme/{id}/draft/issuetype/{issueType}
@required {id: int(int64), issueType: str}
@returns(200) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {401, 403, 404}

@endpoint GET /rest/api/3/workflowscheme/{id}/draft/issuetype/{issueType}
@required {id: int(int64), issueType: str}
@returns(200) {issueType: str, updateDraftIfNeeded: bool, workflow: str}
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/workflowscheme/{id}/draft/issuetype/{issueType}
@required {id: int(int64), issueType: str}
@optional {issueType: str, updateDraftIfNeeded: bool, workflow: str}
@returns(200) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {400, 401, 403, 404}

@endpoint POST /rest/api/3/workflowscheme/{id}/draft/publish
@required {id: int(int64)}
@optional {validateOnly: bool=false, statusMappings: [map{issueTypeId!: str, newStatusId!: str, statusId!: str}]}
@returns(204)
@errors {303, 400, 401, 403, 404}

@endpoint DELETE /rest/api/3/workflowscheme/{id}/draft/workflow
@required {id: int(int64), workflowName: str}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /rest/api/3/workflowscheme/{id}/draft/workflow
@required {id: int(int64)}
@optional {workflowName: str}
@returns(200) {defaultMapping: bool, issueTypes: [str], updateDraftIfNeeded: bool, workflow: str}
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/workflowscheme/{id}/draft/workflow
@required {id: int(int64), workflowName: str}
@optional {defaultMapping: bool, issueTypes: [str], updateDraftIfNeeded: bool, workflow: str}
@returns(200) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/workflowscheme/{id}/issuetype/{issueType}
@required {id: int(int64), issueType: str}
@optional {updateDraftIfNeeded: bool=false}
@returns(200) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/workflowscheme/{id}/issuetype/{issueType}
@required {id: int(int64), issueType: str}
@optional {returnDraftIfExists: bool=false}
@returns(200) {issueType: str, updateDraftIfNeeded: bool, workflow: str}
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/workflowscheme/{id}/issuetype/{issueType}
@required {id: int(int64), issueType: str}
@optional {issueType: str, updateDraftIfNeeded: bool, workflow: str}
@returns(200) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {400, 401, 403, 404}

@endpoint DELETE /rest/api/3/workflowscheme/{id}/workflow
@required {id: int(int64), workflowName: str}
@optional {updateDraftIfNeeded: bool=false}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/workflowscheme/{id}/workflow
@required {id: int(int64)}
@optional {workflowName: str, returnDraftIfExists: bool=false}
@returns(200) {defaultMapping: bool, issueTypes: [str], updateDraftIfNeeded: bool, workflow: str}
@errors {401, 403, 404}

@endpoint PUT /rest/api/3/workflowscheme/{id}/workflow
@required {id: int(int64), workflowName: str}
@optional {defaultMapping: bool, issueTypes: [str], updateDraftIfNeeded: bool, workflow: str}
@returns(200) {defaultWorkflow: str, description: str, draft: bool, id: int(int64), issueTypeMappings: map, issueTypes: map, lastModified: str, lastModifiedUser: any, name: str, originalDefaultWorkflow: str, originalIssueTypeMappings: map, self: str(uri), updateDraftIfNeeded: bool}
@errors {400, 401, 403, 404}

@endpoint GET /rest/api/3/workflowscheme/{workflowSchemeId}/projectUsages
@required {workflowSchemeId: str}
@optional {nextPageToken: str, maxResults: int(int32)=50}
@returns(200) {projects: map{nextPageToken: str, values: [map]}, workflowSchemeId: str}
@errors {400, 401, 404}

@endpoint GET /rest/api/3/worklog/deleted
@optional {since: int(int64)=0}
@returns(200) {lastPage: bool, nextPage: str(uri), self: str(uri), since: int(int64), until: int(int64), values: [map]}
@errors {401}

@endpoint POST /rest/api/3/worklog/list
@required {ids: [int(int64)]}
@optional {expand: str=}
@returns(200)
@errors {400, 401}

@endpoint GET /rest/api/3/worklog/updated
@optional {since: int(int64)=0, expand: str=}
@returns(200) {lastPage: bool, nextPage: str(uri), self: str(uri), since: int(int64), until: int(int64), values: [map]}
@errors {401}

@endpoint GET /rest/atlassian-connect/1/addons/{addonKey}/properties
@required {addonKey: str}
@returns(200) {keys: [map]}
@errors {401}

@endpoint DELETE /rest/atlassian-connect/1/addons/{addonKey}/properties/{propertyKey}
@required {addonKey: str, propertyKey: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/atlassian-connect/1/addons/{addonKey}/properties/{propertyKey}
@required {addonKey: str, propertyKey: str}
@returns(200) {key: str, value: any}
@errors {400, 401, 404}

@endpoint PUT /rest/atlassian-connect/1/addons/{addonKey}/properties/{propertyKey}
@required {addonKey: str, propertyKey: str}
@returns(200) {message: str, statusCode: int}
@returns(201) {message: str, statusCode: int}
@errors {400, 401, 403}

@endpoint DELETE /rest/atlassian-connect/1/app/module/dynamic
@optional {moduleKey: [str]}
@returns(204)
@errors {401}

@endpoint GET /rest/atlassian-connect/1/app/module/dynamic
@returns(200) {modules: [map]}
@errors {401}

@endpoint POST /rest/atlassian-connect/1/app/module/dynamic
@required {modules: [map]}
@returns(200)
@errors {400, 401}

@endpoint PUT /rest/atlassian-connect/1/migration/field
@required {Atlassian-Transfer-Id: str(uuid)}
@optional {updateValueList: [map{_type!: str, fieldID!: int, issueID!: int, number: num, optionID: str, richText: str, string: str, text: str}]}
@returns(200)
@errors {400, 403}

@endpoint PUT /rest/atlassian-connect/1/migration/properties/{entityType}
@required {Atlassian-Transfer-Id: str(uuid), entityType: str(IssueProperty/CommentProperty/DashboardItemProperty/IssueTypeProperty/ProjectProperty/UserProperty/WorklogProperty/BoardProperty/SprintProperty)}
@returns(200)
@errors {400, 403}

@endpoint POST /rest/atlassian-connect/1/migration/workflow/rule/search
@required {Atlassian-Transfer-Id: str(uuid), ruleIds: [str(uuid)], workflowEntityId: str(uuid)}
@optional {expand: str}
@returns(200) {invalidRules: [str(uuid)], validRules: [map], workflowEntityId: str(uuid)}
@errors {400, 403}

@endpoint GET /rest/atlassian-connect/1/migration/{connectKey}/{jiraIssueFieldsKey}/task
@required {connectKey: str, jiraIssueFieldsKey: str}
@returns(200) {description: str, elapsedRuntime: int(int64), finished: str(date-time), id: str, lastUpdate: str(date-time), message: str, progress: int(int64), result: any, self: str(uri), started: str(date-time), status: str, submitted: str(date-time), submittedBy: int(int64)}
@errors {401, 404}

@endpoint POST /rest/atlassian-connect/1/migration/{connectKey}/{jiraIssueFieldsKey}/task
@required {connectKey: str, jiraIssueFieldsKey: str}
@returns(202)
@errors {401, 404, 409}

@endpoint GET /rest/atlassian-connect/1/service-registry
@required {serviceIds: [str]}
@returns(200)
@errors {400, 401, 403, 500, 501, 504}

@endpoint GET /rest/forge/1/app/properties
@returns(200) {keys: [map]}
@errors {401, 403}

@endpoint DELETE /rest/forge/1/app/properties/{propertyKey}
@required {propertyKey: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /rest/forge/1/app/properties/{propertyKey}
@required {propertyKey: str}
@returns(200) {key: str, value: any}
@errors {400, 401, 403, 404}

@endpoint PUT /rest/forge/1/app/properties/{propertyKey}
@required {propertyKey: str}
@returns(200) {message: str, statusCode: int}
@returns(201) {message: str, statusCode: int}
@errors {400, 401, 403}

@endpoint POST /rest/internal/api/latest/worklog/bulk
@optional {requests: [map{issueId: int(int64), worklogId: int(int64)}]}
@returns(200) {worklogs: [map]}
@errors {400, 401, 500}

@end