@lap v0.3
# Machine-readable API spec. Each @endpoint block is one API call.
@api API Reference
@base https://us.sentry.io/api/0
@version v0
@auth Bearer bearer | Bearer DSN
@common_fields {organization_id_or_slug: str}
@endpoints 295
@hint download_for_search
@toc root(1), organizations(186), projects(90), seer(1), sentry-app-installations(4), sentry-apps(3), teams(9), users(1)

@group root
@endpoint GET /
@returns(200) {version: str, auth: map?{scopes: [str]}, user: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map], options: map{theme: str, language: str, stacktraceOrder: int, defaultIssueEvent: str, timezone: str, clock24Hours: bool, prefersIssueDetailsStreamlinedUI: bool?}, flags: map{newsletter_consent_prompt: bool}}}
@errors {401, 429}

@endgroup

@group organizations
@endpoint GET /organizations/
@optional {owner: bool, cursor: str, query: str, sortBy: str, per_page: int}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/
@optional {detailed: str}
@returns(200) {features: [str], extraOptions: map, access: [str], onboardingTasks: [map], id: str, slug: str, status: map{id: str, name: str}, name: str, dateCreated: str(date-time), isEarlyAdopter: bool, require2FA: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, links: map{organizationUrl: str, regionUrl: str}, hasAuthProvider: bool, allowMemberInvite: bool, allowMemberProjectCreation: bool, allowSuperuserAccess: bool}
@errors {401, 403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/
@optional {slug: str, name: str, isEarlyAdopter: bool, hideAiFeatures: bool, defaultRole: str(member/admin/manager/owner), openMembership: bool, eventsMemberAdmin: bool, alertsMemberWrite: bool, attachmentsRole: str(member/admin/manager/owner), debugFilesRole: str(member/admin/manager/owner), hasGranularReplayPermissions: bool, replayAccessMembers: [int], avatarType: str(letter_avatar/upload), avatar: str, require2FA: bool, allowSharedIssues: bool, enhancedPrivacy: bool, scrapeJavaScript: bool, storeCrashReports: int(0/1/5/10/20/50/100/-1), allowJoinRequests: bool, dataScrubber: bool, dataScrubberDefaults: bool, sensitiveFields: [str], safeFields: [str], scrubIPAddresses: bool, relayPiiConfig: str, trustedRelays: [map], relayDsnEndpoint: str, issueAlertsThreadFlag: bool, metricAlertsThreadFlag: bool, cancelDeletion: bool, apdexThreshold: int}
@returns(200) {features: [str], extraOptions: map, access: [str], onboardingTasks: [map], id: str, slug: str, status: map{id: str, name: str}, name: str, dateCreated: str(date-time), isEarlyAdopter: bool, require2FA: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, links: map{organizationUrl: str, regionUrl: str}, hasAuthProvider: bool, allowMemberInvite: bool, allowMemberProjectCreation: bool, allowSuperuserAccess: bool, role: str, orgRole: str, planSampleRate: num(double), desiredSampleRate: num(double), experiments: map, isDefault: bool, defaultRole: str, orgRoleList: [map], teamRoleList: [map], openMembership: bool, allowSharedIssues: bool, enhancedPrivacy: bool, dataScrubber: bool, dataScrubberDefaults: bool, sensitiveFields: [str], safeFields: [str], storeCrashReports: int, attachmentsRole: str, debugFilesRole: str, eventsMemberAdmin: bool, alertsMemberWrite: bool, scrubIPAddresses: bool, scrapeJavaScript: bool, allowJoinRequests: bool, relayPiiConfig: str?, relayDsnEndpoint: str?, trustedRelays: [map], pendingAccessRequests: int, hideAiFeatures: bool, aggregatedDataConsent: bool, isDynamicallySampled: bool, issueAlertsThreadFlag: bool, metricAlertsThreadFlag: bool, requiresSso: bool, defaultAutofixAutomationTuning: str, defaultSeerScannerAutomation: bool, enableSeerCoding: bool, defaultCodingAgent: str, defaultCodingAgentIntegrationId: str?, defaultAutomatedRunStoppingPoint: str, autoEnableCodeReview: bool, autoOpenPrs: bool, defaultCodeReviewTriggers: [str], teams: [map], projects: [map]}
@errors {400, 401, 403, 404, 409, 413}

@endpoint GET /organizations/{organization_id_or_slug}/agents/conversations/
@optional {project: [any], environment: [str], statsPeriod: str, start: str(date-time), end: str(date-time), query: str, sort: str(-conversation.age/-conversation.conversationId/-conversation.errors/-conversation.generationDuration/-conversation.inputTokens/-conversation.llmCalls/-conversation.outputTokens/-conversation.timeSpan/-conversation.toolCalls/-conversation.toolErrors/-conversation.totalCost/-conversation.totalTokens/conversation.age/conversation.conversationId/conversation.errors/conversation.generationDuration/conversation.inputTokens/conversation.llmCalls/conversation.outputTokens/conversation.timeSpan/conversation.toolCalls/conversation.toolErrors/conversation.totalCost/conversation.totalTokens), cursor: str, per_page: int}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/agents/conversations/{conversation_id}/
@required {conversation_id: str}
@optional {project: [any], environment: [str], statsPeriod: str, start: str(date-time), end: str(date-time), cursor: str, per_page: int}
@returns(200) {conversationId: str, title: str?, projects: [map], webUrl: str(uri), spans: [map], stats: map?{endTimestamp: int, errors: int, generationDuration: num(double), inputTokens: int, llmCalls: int, outputTokens: int, startTimestamp: int, toolCalls: int, toolErrors: int, toolNames: [str], totalCost: num(double), totalTokens: int, cacheReadTokens: int, cacheWriteTokens: int, errorToolNames: [str], reasoningTokens: int, cacheReadCost: num(double), cacheWriteCost: num(double), reasoningCost: num(double), usageByModel: [map]}}
@errors {400, 401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/artifactbundle/assemble/
@required {projects: [str], checksum: str, chunks: [str]}
@optional {version: str, dist: str}
@returns(200) {state: str, missingChunks: [str], detail: str?}
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/available-actions/
@optional {type: [str]}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/chunk-upload/
@returns(200) {url: str, chunkSize: int, chunksPerRequest: int, maxFileSize: int, maxRequestSize: int, concurrency: int, hashAlgorithm: str, compression: [str], accept: [str]}
@errors {401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/chunk-upload/
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/code-mappings/
@optional {integrationId: str, project: [str], cursor: str, per_page: int}
@returns(200)
@errors {401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/code-mappings/
@required {repository_id: int, project_id: int, stack_root: str, source_root: str, integration_id: int}
@optional {default_branch: str}
@returns(201) {id: str, projectId: str, projectSlug: str, repoId: str, repoName: str, integrationId: str?, provider: map?{key: str, slug: str, name: str, canAdd: bool, canDisable: bool, features: [str], aspects: map{alerts: [map], configure_integration: map{title: str}, directEnable: bool, disable_dialog: map{actionText: str, body: str}, externalInstall: map{url: str, buttonText: str, noticeText: str}, removal_dialog: map{actionText: str, body: str}}}, stackRoot: str, sourceRoot: str, defaultBranch: str?, automaticallyGenerated: bool, hasCodeOwner: bool}
@errors {400, 401, 403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/code-mappings/{config_id}/
@required {config_id: int, repository_id: int, project_id: int, stack_root: str, source_root: str}
@optional {default_branch: str}
@returns(200) {id: str, projectId: str, projectSlug: str, repoId: str, repoName: str, integrationId: str?, provider: map?{key: str, slug: str, name: str, canAdd: bool, canDisable: bool, features: [str], aspects: map{alerts: [map], configure_integration: map{title: str}, directEnable: bool, disable_dialog: map{actionText: str, body: str}, externalInstall: map{url: str, buttonText: str, noticeText: str}, removal_dialog: map{actionText: str, body: str}}}, stackRoot: str, sourceRoot: str, defaultBranch: str?, automaticallyGenerated: bool, hasCodeOwner: bool}
@errors {400, 401, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/code-mappings/{config_id}/
@required {config_id: int}
@returns(204)
@errors {401, 403, 404, 409}

@endpoint POST /organizations/{organization_id_or_slug}/code-mappings/bulk/
@required {project: any, repository: str, mappings: [map{stack_root!: str, source_root!: str}]}
@optional {provider: str, default_branch: str}
@returns(200) {created: int, updated: int, errors: int, mappings: [map]}
@returns(207) {created: int, updated: int, errors: int, mappings: [map]}
@errors {400, 401, 403, 404, 409}

@endpoint GET /organizations/{organization_id_or_slug}/codeowners-associations/
@optional {project: [str], provider: str}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/config/integrations/
@optional {providerKey: str}
@returns(200) {providers: [map]}
@errors {404}

@endpoint GET /organizations/{organization_id_or_slug}/dashboards/
@optional {filter: [str], query: str, sort: str, pin: str, per_page: int, cursor: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/dashboards/
@required {title: str}
@optional {id: str, widgets: [map{id: str, title: str, description: str, thresholds: map, display_type: str, interval: str, queries: [map], widget_type: str, limit: int, layout: any, axis_range: str, legend_type: str}], projects: [int], environment: [str], period: str, start: str(date-time), end: str(date-time), filters: map, utc: bool, permissions: any, query_priority: str(normal/faster), is_favorited: bool=false}
@returns(201) {environment: [str], period: str, utc: str, expired: bool, start: str(date-time), end: str(date-time), id: str, title: str, dateCreated: str(date-time), createdBy: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, widgets: [map], projects: [int], filters: map{release: [str], releaseId: [str], globalFilter: [map]}, permissions: map?{isEditableByEveryone: bool, teamsWithEditAccess: [int]}, isFavorited: bool, prebuiltId: int?, queryPriority: str}
@errors {400, 401, 403, 404, 409}

@endpoint GET /organizations/{organization_id_or_slug}/dashboards/{dashboard_id}/
@required {dashboard_id: int}
@returns(200) {environment: [str], period: str, utc: str, expired: bool, start: str(date-time), end: str(date-time), id: str, title: str, dateCreated: str(date-time), createdBy: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, widgets: [map], projects: [int], filters: map{release: [str], releaseId: [str], globalFilter: [map]}, permissions: map?{isEditableByEveryone: bool, teamsWithEditAccess: [int]}, isFavorited: bool, prebuiltId: int?, queryPriority: str}
@errors {403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/dashboards/{dashboard_id}/
@required {dashboard_id: int}
@optional {id: str, title: str, widgets: [map{id: str, title: str, description: str, thresholds: map, display_type: str, interval: str, queries: [map], widget_type: str, limit: int, layout: any, axis_range: str, legend_type: str}], projects: [int], environment: [str], period: str, start: str(date-time), end: str(date-time), filters: map, utc: bool, permissions: any, query_priority: str(normal/faster)}
@returns(200) {environment: [str], period: str, utc: str, expired: bool, start: str(date-time), end: str(date-time), id: str, title: str, dateCreated: str(date-time), createdBy: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, widgets: [map], projects: [int], filters: map{release: [str], releaseId: [str], globalFilter: [map]}, permissions: map?{isEditableByEveryone: bool, teamsWithEditAccess: [int]}, isFavorited: bool, prebuiltId: int?, queryPriority: str}
@errors {400, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/dashboards/{dashboard_id}/
@required {dashboard_id: int}
@returns(204)
@errors {403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/dashboards/{dashboard_id}/revisions/
@required {dashboard_id: int}
@optional {per_page: int, cursor: str}
@returns(200)
@errors {403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/dashboards/{dashboard_id}/revisions/{revision_id}/restore/
@required {dashboard_id: int, revision_id: int}
@returns(200) {environment: [str], period: str, utc: str, expired: bool, start: str(date-time), end: str(date-time), id: str, title: str, dateCreated: str(date-time), createdBy: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, widgets: [map], projects: [int], filters: map{release: [str], releaseId: [str], globalFilter: [map]}, permissions: map?{isEditableByEveryone: bool, teamsWithEditAccess: [int]}, isFavorited: bool, prebuiltId: int?, queryPriority: str}
@errors {400, 403, 404, 409}

@endpoint GET /organizations/{organization_id_or_slug}/detectors/
@optional {project: [any], query: str, sortBy: str, id: [int], type: [str], enabled: bool, per_page: int, cursor: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/detectors/
@required {enabled: bool}
@optional {project: [any], query: str, id: [int]}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/detectors/
@optional {project: [any], query: str, sortBy: str, id: [int]}
@returns(200)
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/detectors/{detector_id}/
@required {detector_id: int}
@returns(200) {owner: map?{type: str, id: str, name: str, email: str}, createdBy: str?, latestGroup: map?{id: str, title: str, culprit: str?, shortId: str?, level: str, status: str, substatus: str?, platform: str?, project: map{id: str, name: str, slug: str, platform: str?}, type: str, issueType: str, issueCategory: str, metadata: map{title: str, value: str, type: str, synthetic: bool, filename: str, function: str, message: str, uri: str, directive: str, origin: str, name: str, contact_email: str, source: str, in_app_frame_mix: str, stripped_crash: bool, sdk: map{name: str, name_normalized: str}, severity: num(double), severity_reason: str, initial_priority: int}, numComments: int, firstSeen: str(date-time)?, lastSeen: str(date-time)?}, description: str?, id: str, projectId: str?, name: str, type: str, workflowIds: [str]?, dateCreated: str(date-time), dateUpdated: str(date-time), dataSources: [map]?, conditionGroup: map?{id: str, organizationId: str, logicType: str, conditions: [map], actions: [map]}, config: any, enabled: bool}
@errors {400, 401, 403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/detectors/{detector_id}/
@required {detector_id: int}
@optional {name: str, type: str, workflowIds: [int], dataSources: [any], config: map, conditionGroup: any, owner: str, description: str, enabled: bool}
@returns(200) {owner: map?{type: str, id: str, name: str, email: str}, createdBy: str?, latestGroup: map?{id: str, title: str, culprit: str?, shortId: str?, level: str, status: str, substatus: str?, platform: str?, project: map{id: str, name: str, slug: str, platform: str?}, type: str, issueType: str, issueCategory: str, metadata: map{title: str, value: str, type: str, synthetic: bool, filename: str, function: str, message: str, uri: str, directive: str, origin: str, name: str, contact_email: str, source: str, in_app_frame_mix: str, stripped_crash: bool, sdk: map{name: str, name_normalized: str}, severity: num(double), severity_reason: str, initial_priority: int}, numComments: int, firstSeen: str(date-time)?, lastSeen: str(date-time)?}, description: str?, id: str, projectId: str?, name: str, type: str, workflowIds: [str]?, dateCreated: str(date-time), dateUpdated: str(date-time), dataSources: [map]?, conditionGroup: map?{id: str, organizationId: str, logicType: str, conditions: [map], actions: [map]}, config: any, enabled: bool}
@errors {400, 401, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/detectors/{detector_id}/
@required {detector_id: int}
@returns(204)
@errors {403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/discover/saved/
@optional {per_page: int, cursor: str, query: str, sortBy: str}
@returns(200)
@errors {400, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/discover/saved/
@required {name: str}
@optional {projects: [int], queryDataset: str(discover/error-events/transaction-like)=error-events, start: str(date-time), end: str(date-time), range: str, fields: [str], orderby: str, rollup: int, aggregations: [[any]], groupby: [str], conditions: [[any]], limit: int, version: int, environment: [str], query: str, widths: [str], yAxis: [str], display: str, topEvents: int, interval: str}
@returns(201) {environment: [str], query: str, fields: [str], widths: [str], conditions: [str], aggregations: [str], range: str, start: str, end: str, orderby: str, limit: str, yAxis: [str], display: str, topEvents: int, interval: str, exploreQuery: map?{environment: [str], query: [map], statsPeriod: str, start: str, end: str, interval: str, id: str, name: str, projects: [int], dataset: str, expired: bool, isPrebuilt: bool, changedReason: map?{orderby: [map]?, equations: [map]?, columns: [str]}}, lastVisited: str(date-time)?, starred: bool, position: int?, id: str, name: str, projects: [int], version: int, queryDataset: str, datasetSource: str, expired: bool, dateCreated: str(date-time), dateUpdated: str(date-time), createdBy: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}}
@errors {400, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/discover/saved/{query_id}/
@required {query_id: int}
@returns(200) {environment: [str], query: str, fields: [str], widths: [str], conditions: [str], aggregations: [str], range: str, start: str, end: str, orderby: str, limit: str, yAxis: [str], display: str, topEvents: int, interval: str, exploreQuery: map?{environment: [str], query: [map], statsPeriod: str, start: str, end: str, interval: str, id: str, name: str, projects: [int], dataset: str, expired: bool, isPrebuilt: bool, changedReason: map?{orderby: [map]?, equations: [map]?, columns: [str]}}, lastVisited: str(date-time)?, starred: bool, position: int?, id: str, name: str, projects: [int], version: int, queryDataset: str, datasetSource: str, expired: bool, dateCreated: str(date-time), dateUpdated: str(date-time), createdBy: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}}
@errors {403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/discover/saved/{query_id}/
@required {query_id: int, name: str}
@optional {projects: [int], queryDataset: str(discover/error-events/transaction-like)=error-events, start: str(date-time), end: str(date-time), range: str, fields: [str], orderby: str, rollup: int, aggregations: [[any]], groupby: [str], conditions: [[any]], limit: int, version: int, environment: [str], query: str, widths: [str], yAxis: [str], display: str, topEvents: int, interval: str}
@returns(200) {environment: [str], query: str, fields: [str], widths: [str], conditions: [str], aggregations: [str], range: str, start: str, end: str, orderby: str, limit: str, yAxis: [str], display: str, topEvents: int, interval: str, exploreQuery: map?{environment: [str], query: [map], statsPeriod: str, start: str, end: str, interval: str, id: str, name: str, projects: [int], dataset: str, expired: bool, isPrebuilt: bool, changedReason: map?{orderby: [map]?, equations: [map]?, columns: [str]}}, lastVisited: str(date-time)?, starred: bool, position: int?, id: str, name: str, projects: [int], version: int, queryDataset: str, datasetSource: str, expired: bool, dateCreated: str(date-time), dateUpdated: str(date-time), createdBy: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}}
@errors {400, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/discover/saved/{query_id}/
@required {query_id: int}
@returns(204)
@errors {403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/dsn-lookup/
@required {dsn: str}
@returns(200) {organizationSlug: str, projectSlug: str, projectId: str, projectName: str, projectPlatform: str?, keyLabel: str?, keyId: str}
@errors {400, 401, 403, 404, 429}

@endpoint GET /organizations/{organization_id_or_slug}/environments/
@optional {visibility: str(all/hidden/visible)=visible}
@returns(200)
@errors {400, 403}

@endpoint GET /organizations/{organization_id_or_slug}/eventids/{event_id}/
@required {event_id: str}
@returns(200) {organizationSlug: str, projectSlug: str, groupId: str, eventId: str, event: map{id: str, groupID: str?, eventID: str, projectID: str, message: str?, title: str, location: str?, platform: str?, dateReceived: str(date-time)?, size: int?, entries: [any], dist: str?, packages: map, type: str, metadata: map{title: str, value: str, type: str, synthetic: bool, filename: str, function: str, message: str, uri: str, directive: str, origin: str, name: str, contact_email: str, source: str, in_app_frame_mix: str, stripped_crash: bool, sdk: map{name: str, name_normalized: str}, severity: num(double), severity_reason: str, initial_priority: int}, occurrence: any, _meta: map, user: map?{id: str?, email: str?, username: str?, ip_address: str?, name: str?, geo: map?, data: map?}, tags: [map], contexts: map?, sdk: map?{name: str?, version: str?}, context: map?, errors: [map], crashFile: str?, culprit: str?, dateCreated: str(date-time), fingerprints: [str], groupingConfig: map{id: str, enhancements: str}, startTimestamp: num(double), endTimestamp: num(double), measurements: map?, breakdowns: map?}}
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/events/
@required {field: [str], dataset: str(errors/logs/profile_functions/spans/tracemetrics/uptime_results)}
@optional {end: str(date-time), environment: [str], referrer: str, project: [any], start: str(date-time), statsPeriod: str, per_page: int, query: str, sort: str, allowAggregateConditions: bool, cursor: str}
@returns(200) {data: [map], meta: map{fields: map, units: map, tips: map, datasetReason: str, isMetricsData: bool, isMetricsExtractedData: bool, dataset: str, discoverSplitDecision: str, dataScanned: str, bytesScanned: int, routingHint: str, debug_info: any, ingestion: map{status: str, delaySeconds: num(double), completeThrough: num(double)}}}
@errors {400, 403}

@endpoint GET /organizations/{organization_id_or_slug}/events-dropped/
@required {dataset: str(errors/logs/profile_functions/spans/tracemetrics/uptime_results)}
@optional {end: str(date-time), environment: [str], project: [any], start: str(date-time), statsPeriod: str, interval: any, outcome: str(filtered/rate_limited/invalid/abuse/client_discard/cardinality_limited), reason: str}
@returns(200) {meta: map{dataset: str, start: num(double), end: num(double), interval: num(double), suppressedDrops: [map]}, droppedEvents: [map], acceptedEvents: [map]}
@errors {400, 404}

@endpoint GET /organizations/{organization_id_or_slug}/events-timeseries/
@required {dataset: str(errors/logs/profile_functions/spans/tracemetrics/uptime_results)}
@optional {end: str(date-time), environment: [str], project: [any], start: str(date-time), statsPeriod: str, topEvents: int, comparisonDelta: int, interval: any, sort: str, groupBy: [str], yAxis: [str], transformations[0]: [str], query: str, disableAggregateExtrapolation: str(0/1), preventMetricAggregates: str(0/1), excludeOther: str(0/1)}
@returns(200) {meta: map{dataset: str, start: num(double), end: num(double), ingestion: map{status: str, delaySeconds: num(double), completeThrough: num(double)}}, timeSeries: [map]}
@errors {400, 404}

@endpoint POST /organizations/{organization_id_or_slug}/external-users/
@required {user_id: int, external_name: str, provider: str(github/github_enterprise/jira_server/slack/slack_staging/perforce/gitlab/cursor_origin/msteams/custom_scm), integration_id: int, id: int}
@optional {external_id: str}
@returns(200) {externalId: str, userId: str, teamId: str, id: str, provider: str, externalName: str, integrationId: str}
@returns(201) {externalId: str, userId: str, teamId: str, id: str, provider: str, externalName: str, integrationId: str}
@errors {400, 403}

@endpoint PUT /organizations/{organization_id_or_slug}/external-users/{external_user_id}/
@required {external_user_id: int, user_id: int, external_name: str, provider: str(github/github_enterprise/jira_server/slack/slack_staging/perforce/gitlab/cursor_origin/msteams/custom_scm), integration_id: int, id: int}
@optional {external_id: str}
@returns(200) {externalId: str, userId: str, teamId: str, id: str, provider: str, externalName: str, integrationId: str}
@errors {400, 403}

@endpoint DELETE /organizations/{organization_id_or_slug}/external-users/{external_user_id}/
@required {external_user_id: int}
@returns(204)
@errors {400, 403}

@endpoint GET /organizations/{organization_id_or_slug}/flags/logs/
@optional {start: str(date-time), end: str(date-time), statsPeriod: str, statsPeriodStart: str, statsPeriodEnd: str, flag: [str], provider: [str], sort: str, per_page: int, cursor: str}
@returns(200) {data: [map]}
@errors {400, 401, 403}

@endpoint GET /organizations/{organization_id_or_slug}/flags/logs/{flag_log_id}/
@required {flag_log_id: int}
@returns(200) {data: map{id: int, action: str, createdAt: str, createdBy: str?, createdByType: str?, flag: str, provider: str?, tags: map}}
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/forwarding/
@returns(200)

@endpoint POST /organizations/{organization_id_or_slug}/forwarding/
@required {organization_id: int, provider: str(segment/sqs/splunk)}
@optional {is_enabled: bool=true, enroll_new_projects: bool=false, config: map, project_ids: [int]}
@returns(201) {id: str, organizationId: str, isEnabled: bool, enrollNewProjects: bool, enrolledProjects: [map], provider: str, config: map?, projectConfigs: [map], dateAdded: str(date-time), dateUpdated: str(date-time)}
@errors {400, 403}

@endpoint PUT /organizations/{organization_id_or_slug}/forwarding/{data_forwarder_id}/
@required {data_forwarder_id: int, organization_id: int, provider: str(segment/sqs/splunk)}
@optional {is_enabled: bool=true, enroll_new_projects: bool=false, config: map, project_ids: [int]}
@returns(200) {id: str, organizationId: str, isEnabled: bool, enrollNewProjects: bool, enrolledProjects: [map], provider: str, config: map?, projectConfigs: [map], dateAdded: str(date-time), dateUpdated: str(date-time)}
@errors {400, 403}

@endpoint DELETE /organizations/{organization_id_or_slug}/forwarding/{data_forwarder_id}/
@required {data_forwarder_id: int}
@returns(204)
@errors {403}

@endpoint GET /organizations/{organization_id_or_slug}/group-search-views/
@optional {createdBy: str(me/others), sort: [str]=-visited, query: str, cursor: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/group-search-views/
@required {name: str, query: str, projects: [int], environments: [str], timeFilters: any}
@optional {querySort: str(date/new/trends/freq/user/inbox/recommended)=date, starred: bool}
@returns(201) {id: str, createdBy: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, name: str, query: str, querySort: str, projects: [int], environments: [str], timeFilters: map{start: str?, end: str?, period: str?, utc: bool?}, lastVisited: str(date-time)?, dateCreated: str(date-time)?, dateUpdated: str(date-time), starred: bool, stars: int}
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/integrations/
@optional {providerKey: str, features: [str], includeConfig: bool, cursor: str}
@returns(200)
@errors {400}

@endpoint GET /organizations/{organization_id_or_slug}/integrations/{integration_id}/
@required {integration_id: str}
@returns(200) {id: str, name: str, icon: str?, domainName: str?, accountType: str?, scopes: [str]?, outOfDate: bool?, missingFeatures: [map]?, status: str, provider: map{key: str, slug: str, name: str, canAdd: bool, canDisable: bool, features: [str], aspects: map{alerts: [map], configure_integration: map{title: str}, directEnable: bool, disable_dialog: map{actionText: str, body: str}, externalInstall: map{url: str, buttonText: str, noticeText: str}, removal_dialog: map{actionText: str, body: str}}}, configOrganization: any, configData: any, externalId: str, organizationId: int, organizationIntegrationStatus: str, gracePeriodEnd: str(date-time)?}

@endpoint DELETE /organizations/{organization_id_or_slug}/integrations/{integration_id}/
@required {integration_id: str}
@returns(204)
@errors {404}

@endpoint GET /organizations/{organization_id_or_slug}/integrations/{integration_id}/channel-validate/
@required {integration_id: str, channel: str}
@returns(200) {detail: str, valid: bool}
@errors {400, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/integrations/{integration_id}/channels/
@required {integration_id: str}
@returns(200) {warning: str, results: [map]}
@errors {400, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/integrations/{integration_id}/repos/
@required {integration_id: str}
@optional {search: str, installableOnly: bool, accessibleOnly: bool}
@returns(200) {repos: [map], searchable: bool}
@errors {400, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/issues/
@optional {environment: [str], project: [any], statsPeriod: str, statsPeriodStart: str, statsPeriodEnd: str, start: str(date-time), end: str(date-time), groupStatsPeriod: str(/14d/24h/auto), shortIdLookup: str(0/1), query: str=is:unresolved, sort: str(date/freq/inbox/new/recommended/trends/user)=date, limit: int=100, expand: [str], collapse: [str], cursor: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/issues/
@optional {environment: [str], project: [any], id: [int], statsPeriod: str, start: str(date-time), end: str(date-time), query: str=is:unresolved, sort: str(date/freq/inbox/new/recommended/trends/user)=date, inbox: bool, status: str(resolved/unresolved/ignored/resolvedInNextRelease/muted), statusDetails: any, substatus: str(archived_until_escalating/archived_until_condition_met/archived_forever/escalating/ongoing/regressed/new), hasSeen: bool, isBookmarked: bool, isPublic: bool, isSubscribed: bool, merge: bool, discard: bool, assignedTo: str, priority: str(low/medium/high), ignoreDuration: int, ignoreCount: int, ignoreWindow: int, ignoreUserCount: int, ignoreUserWindow: int, snoozeDuration: int}
@returns(200) {assignedTo: map{type: str, id: str, name: str, email: str}, discard: bool, hasSeen: bool, inbox: bool, isBookmarked: bool, isPublic: bool, isSubscribed: bool, merge: map{parent: str, children: [str]}, priority: str, shareId: str, status: str, statusDetails: map{inNextRelease: bool, inRelease: str, inCommit: map{commit: str, repository: str}, ignoreDuration: int, ignoreCount: int, ignoreWindow: int, ignoreUserCount: int, ignoreUserWindow: int}, subscriptionDetails: map{disabled: bool, reason: str}, substatus: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/issues/
@optional {environment: [str], project: [any], id: [int], statsPeriod: str, start: str(date-time), end: str(date-time), query: str=is:unresolved, sort: str(date/freq/inbox/new/recommended/trends/user)=date}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/members/
@optional {query: str, cursor: str}
@returns(200)
@errors {401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/members/
@required {email: str(email)}
@optional {role: str(member/admin/manager/owner)=member, orgRole: str(billing/member/manager/owner/admin)=member, teams: [any], teamRoles: [map], sendInvite: bool=true, reinvite: bool, regenerate: bool}
@returns(201) {externalUsers: [map], id: str, email: str, name: str, user: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, orgRole: str, pending: bool, expired: bool, flags: map{idp:provisioned: bool, idp:role-restricted: bool, sso:linked: bool, sso:invalid: bool, member-limit:restricted: bool, partnership:restricted: bool}, dateCreated: str(date-time), inviteStatus: str?, inviterName: str?}
@errors {400, 401, 403, 404, 429}

@endpoint GET /organizations/{organization_id_or_slug}/members/{member_id}/
@required {member_id: str}
@returns(200) {externalUsers: [map], role: str, roleName: str, id: str, email: str, name: str, user: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, orgRole: str, pending: bool, expired: bool, flags: map{idp:provisioned: bool, idp:role-restricted: bool, sso:linked: bool, sso:invalid: bool, member-limit:restricted: bool, partnership:restricted: bool}, dateCreated: str(date-time), inviteStatus: str?, inviterName: str?, teams: [str], teamRoles: [map], isOnlyOwner: bool, orgRoleList: [map], teamRoleList: [map]}
@errors {401, 403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/members/{member_id}/
@required {member_id: str}
@optional {orgRole: str(billing/member/manager/owner/admin), teamRoles: [map]}
@returns(200) {externalUsers: [map], role: str, roleName: str, id: str, email: str, name: str, user: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, orgRole: str, pending: bool, expired: bool, flags: map{idp:provisioned: bool, idp:role-restricted: bool, sso:linked: bool, sso:invalid: bool, member-limit:restricted: bool, partnership:restricted: bool}, dateCreated: str(date-time), inviteStatus: str?, inviterName: str?, teams: [str], teamRoles: [map], isOnlyOwner: bool, orgRoleList: [map], teamRoleList: [map]}
@errors {400, 401, 403, 429}

@endpoint DELETE /organizations/{organization_id_or_slug}/members/{member_id}/
@required {member_id: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/members/{member_id}/teams/{team_id_or_slug}/
@required {member_id: str, team_id_or_slug: str}
@returns(201) {id: str, slug: str, name: str, dateCreated: str(date-time)?, isMember: bool, teamRole: str?, flags: map, access: [str], hasAccess: bool, isPending: bool, memberCount: int, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}}
@returns(202)
@returns(204)
@errors {401, 403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/members/{member_id}/teams/{team_id_or_slug}/
@required {member_id: str, team_id_or_slug: str}
@optional {teamRole: str(contributor/admin)=contributor}
@returns(200) {isActive: bool, teamRole: str}
@errors {400, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/members/{member_id}/teams/{team_id_or_slug}/
@required {member_id: str, team_id_or_slug: str}
@returns(200) {id: str, slug: str, name: str, dateCreated: str(date-time)?, isMember: bool, teamRole: str?, flags: map, access: [str], hasAccess: bool, isPending: bool, memberCount: int, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}}
@errors {400, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/monitors/
@optional {project: [any], environment: [str], owner: str, cursor: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/monitors/
@required {project: str, name: str, config: any}
@optional {slug: str, status: str(active/disabled)=active, owner: str, is_muted: bool}
@returns(201) {id: str, name: str, slug: str, status: str, isMuted: bool, isUpserting: bool, config: map{schedule_type: str, schedule: any, checkin_margin: int?, max_runtime: int?, timezone: str?, failure_issue_threshold: int?, recovery_threshold: int?, alert_rule_id: int?}, dateCreated: str(date-time), project: map{stats: any, transactionStats: [[int]], sessionStats: map{currentCrashFreeRate: num(double)?, previousCrashFreeRate: num(double)?, hasHealthData: bool}, id: str, slug: str, name: str, platform: str?, dateCreated: str(date-time), isBookmarked: bool, isMember: bool, features: [str], firstEvent: str(date-time)?, firstTransactionEvent: bool, access: [str], hasAccess: bool, hasFeedbacks: bool, hasFlags: bool, hasMinifiedStackTrace: bool, hasMonitors: bool, hasNewFeedbacks: bool, hasProfiles: bool, hasReplays: bool, hasSessions: bool, hasInsightsHttp: bool, hasInsightsDb: bool, hasInsightsAssets: bool, hasInsightsAppStart: bool, hasInsightsScreenLoad: bool, hasInsightsVitals: bool, hasInsightsCaches: bool, hasInsightsQueues: bool, hasInsightsAgentMonitoring: bool, hasInsightsMCP: bool, hasLogs: bool, hasTraceMetrics: bool, isInternal: bool, isPublic: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, color: str, status: str}, environments: [map], owner: map?{type: str, id: str, name: str, email: str}}
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/monitors/{monitor_id_or_slug}/
@required {monitor_id_or_slug: str}
@optional {environment: [str]}
@returns(200) {id: str, name: str, slug: str, status: str, isMuted: bool, isUpserting: bool, config: map{schedule_type: str, schedule: any, checkin_margin: int?, max_runtime: int?, timezone: str?, failure_issue_threshold: int?, recovery_threshold: int?, alert_rule_id: int?}, dateCreated: str(date-time), project: map{stats: any, transactionStats: [[int]], sessionStats: map{currentCrashFreeRate: num(double)?, previousCrashFreeRate: num(double)?, hasHealthData: bool}, id: str, slug: str, name: str, platform: str?, dateCreated: str(date-time), isBookmarked: bool, isMember: bool, features: [str], firstEvent: str(date-time)?, firstTransactionEvent: bool, access: [str], hasAccess: bool, hasFeedbacks: bool, hasFlags: bool, hasMinifiedStackTrace: bool, hasMonitors: bool, hasNewFeedbacks: bool, hasProfiles: bool, hasReplays: bool, hasSessions: bool, hasInsightsHttp: bool, hasInsightsDb: bool, hasInsightsAssets: bool, hasInsightsAppStart: bool, hasInsightsScreenLoad: bool, hasInsightsVitals: bool, hasInsightsCaches: bool, hasInsightsQueues: bool, hasInsightsAgentMonitoring: bool, hasInsightsMCP: bool, hasLogs: bool, hasTraceMetrics: bool, isInternal: bool, isPublic: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, color: str, status: str}, environments: [map], owner: map?{type: str, id: str, name: str, email: str}}
@errors {401, 403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/monitors/{monitor_id_or_slug}/
@required {monitor_id_or_slug: str, project: str, name: str, config: any}
@optional {slug: str, status: str(active/disabled)=active, owner: str, is_muted: bool}
@returns(200) {id: str, name: str, slug: str, status: str, isMuted: bool, isUpserting: bool, config: map{schedule_type: str, schedule: any, checkin_margin: int?, max_runtime: int?, timezone: str?, failure_issue_threshold: int?, recovery_threshold: int?, alert_rule_id: int?}, dateCreated: str(date-time), project: map{stats: any, transactionStats: [[int]], sessionStats: map{currentCrashFreeRate: num(double)?, previousCrashFreeRate: num(double)?, hasHealthData: bool}, id: str, slug: str, name: str, platform: str?, dateCreated: str(date-time), isBookmarked: bool, isMember: bool, features: [str], firstEvent: str(date-time)?, firstTransactionEvent: bool, access: [str], hasAccess: bool, hasFeedbacks: bool, hasFlags: bool, hasMinifiedStackTrace: bool, hasMonitors: bool, hasNewFeedbacks: bool, hasProfiles: bool, hasReplays: bool, hasSessions: bool, hasInsightsHttp: bool, hasInsightsDb: bool, hasInsightsAssets: bool, hasInsightsAppStart: bool, hasInsightsScreenLoad: bool, hasInsightsVitals: bool, hasInsightsCaches: bool, hasInsightsQueues: bool, hasInsightsAgentMonitoring: bool, hasInsightsMCP: bool, hasLogs: bool, hasTraceMetrics: bool, isInternal: bool, isPublic: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, color: str, status: str}, environments: [map], owner: map?{type: str, id: str, name: str, email: str}}
@errors {400, 401, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/monitors/{monitor_id_or_slug}/
@required {monitor_id_or_slug: str}
@optional {environment: [str]}
@returns(202)
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/monitors/{monitor_id_or_slug}/checkins/
@required {monitor_id_or_slug: str}
@optional {cursor: str}
@returns(200)
@errors {401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/notebooks/
@required {title: str}
@optional {projectIds: [int], filters: map, source: map{type!: str}}
@returns(200) {id: str, title: str, summary: str?, summaryDescription: str?, status: str, sourceType: str, createdBy: str?, creator: map?{type: str, id: str}, dateCreated: str(date-time), dateUpdated: str(date-time), version: int, blockCount: int, isFavorited: bool, titleGeneration: map{status: str?}, orchestration: map?{phase: str, status: str, heartbeatAt: str(date-time)?, notebookRevision: int}, template: map?{key: str?, version: int?}, source: map{snapshot: map, type: str, ref: map, revision: int?}, filters: map, projectIds: [int], parameters: [map], blocks: [map], actionRequests: [map]}
@returns(201) {id: str, title: str, summary: str?, summaryDescription: str?, status: str, sourceType: str, createdBy: str?, creator: map?{type: str, id: str}, dateCreated: str(date-time), dateUpdated: str(date-time), version: int, blockCount: int, isFavorited: bool, titleGeneration: map{status: str?}, orchestration: map?{phase: str, status: str, heartbeatAt: str(date-time)?, notebookRevision: int}, template: map?{key: str?, version: int?}, source: map{snapshot: map, type: str, ref: map, revision: int?}, filters: map, projectIds: [int], parameters: [map], blocks: [map], actionRequests: [map]}
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/notebooks/{notebook_id}/
@required {notebook_id: str}
@returns(200) {id: str, title: str, summary: str?, summaryDescription: str?, status: str, sourceType: str, createdBy: str?, creator: map?{type: str, id: str}, dateCreated: str(date-time), dateUpdated: str(date-time), version: int, blockCount: int, isFavorited: bool, titleGeneration: map{status: str?}, orchestration: map?{phase: str, status: str, heartbeatAt: str(date-time)?, notebookRevision: int}, template: map?{key: str?, version: int?}, source: map{snapshot: map, type: str, ref: map, revision: int?}, filters: map, projectIds: [int], parameters: [map], blocks: [map], actionRequests: [map]}
@errors {400, 401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/notebooks/{notebook_id}/blocks/
@required {notebook_id: str, kind: str(text/query)}
@optional {notebookVersion: int, key: str, revision: int, position: int, title: str, content: str, generationPrompt: str, config: map, display: map}
@returns(200) {id: str, position: int, kind: str, title: str, content: str, generationPrompt: str, generatedContent: str, output: any, outputStatus: str, currentExecution: map?{id: str, status: str, executor: str, schemaVersion: int, startedAt: str(date-time)?, completedAt: str(date-time)?, error: any}, config: map, display: map, dependencies: [str], parameterKeys: [str], version: int, staleAt: str(date-time)?, createdBy: str?, lastEditedBy: str?, producerKey: str?, producerRevision: int?}
@returns(201) {id: str, position: int, kind: str, title: str, content: str, generationPrompt: str, generatedContent: str, output: any, outputStatus: str, currentExecution: map?{id: str, status: str, executor: str, schemaVersion: int, startedAt: str(date-time)?, completedAt: str(date-time)?, error: any}, config: map, display: map, dependencies: [str], parameterKeys: [str], version: int, staleAt: str(date-time)?, createdBy: str?, lastEditedBy: str?, producerKey: str?, producerRevision: int?}
@errors {400, 401, 403, 404, 409}

@endpoint PUT /organizations/{organization_id_or_slug}/notebooks/{notebook_id}/blocks/{block_id}/
@required {notebook_id: str, block_id: str, notebookVersion: int, version: int}
@optional {title: str, content: str, generationPrompt: str, config: map, display: map}
@returns(200) {id: str, position: int, kind: str, title: str, content: str, generationPrompt: str, generatedContent: str, output: any, outputStatus: str, currentExecution: map?{id: str, status: str, executor: str, schemaVersion: int, startedAt: str(date-time)?, completedAt: str(date-time)?, error: any}, config: map, display: map, dependencies: [str], parameterKeys: [str], version: int, staleAt: str(date-time)?, createdBy: str?, lastEditedBy: str?, producerKey: str?, producerRevision: int?}
@errors {400, 401, 403, 404, 409}

@endpoint DELETE /organizations/{organization_id_or_slug}/notebooks/{notebook_id}/blocks/{block_id}/
@required {notebook_id: str, block_id: str, notebookVersion: int, version: int}
@returns(204)
@errors {400, 401, 403, 404, 409}

@endpoint PUT /organizations/{organization_id_or_slug}/notebooks/{notebook_id}/blocks/order/
@required {notebook_id: str, notebookVersion: int, blockIds: [int]}
@returns(200) {id: str, title: str, summary: str?, summaryDescription: str?, status: str, sourceType: str, createdBy: str?, creator: map?{type: str, id: str}, dateCreated: str(date-time), dateUpdated: str(date-time), version: int, blockCount: int, isFavorited: bool, titleGeneration: map{status: str?}, orchestration: map?{phase: str, status: str, heartbeatAt: str(date-time)?, notebookRevision: int}, template: map?{key: str?, version: int?}, source: map{snapshot: map, type: str, ref: map, revision: int?}, filters: map, projectIds: [int], parameters: [map], blocks: [map], actionRequests: [map]}
@errors {400, 401, 403, 404, 409}

@endpoint GET /organizations/{organization_id_or_slug}/notifications/actions/
@optional {project: [any], project_id_or_slug: [str], triggerType: str}
@returns(201) {id: int, organizationId: int, integrationId: int?, sentryAppId: int?, projects: [int], serviceType: str?, triggerType: str, targetType: str?, targetIdentifier: str?, targetDisplay: str?}
@errors {400, 403}

@endpoint POST /organizations/{organization_id_or_slug}/notifications/actions/
@required {trigger_type: str, service_type: str}
@optional {integration_id: int, target_identifier: str, target_display: str, projects: [str], sentry_app_id: int, target_type: str=specific}
@returns(201) {id: int, organizationId: int, integrationId: int?, sentryAppId: int?, projects: [int], serviceType: str?, triggerType: str, targetType: str?, targetIdentifier: str?, targetDisplay: str?}
@errors {400, 403}

@endpoint GET /organizations/{organization_id_or_slug}/notifications/actions/{action_id}/
@required {action_id: int}
@returns(200) {id: int, organizationId: int, integrationId: int?, sentryAppId: int?, projects: [int], serviceType: str?, triggerType: str, targetType: str?, targetIdentifier: str?, targetDisplay: str?}

@endpoint PUT /organizations/{organization_id_or_slug}/notifications/actions/{action_id}/
@required {action_id: int, trigger_type: str, service_type: str}
@optional {integration_id: int, target_identifier: str, target_display: str, projects: [str], sentry_app_id: int, target_type: str=specific}
@returns(202) {id: int, organizationId: int, integrationId: int?, sentryAppId: int?, projects: [int], serviceType: str?, triggerType: str, targetType: str?, targetIdentifier: str?, targetDisplay: str?}
@errors {400}

@endpoint DELETE /organizations/{organization_id_or_slug}/notifications/actions/{action_id}/
@required {action_id: int}
@returns(204)

@endpoint GET /organizations/{organization_id_or_slug}/org-auth-tokens/
@returns(200)
@errors {403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/org-auth-tokens/
@optional {name: str, scopes: [str]}
@returns(201) {id: str, name: str, scopes: [str], tokenLastCharacters: str?, dateCreated: str(date-time), dateLastUsed: str(date-time)?, projectLastUsedId: str?, token: str}
@errors {400, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/org-auth-tokens/{token_id}/
@required {token_id: int}
@returns(204)
@errors {403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/preprodartifacts/{artifact_id}/install-details/
@required {artifact_id: str}
@returns(200) {buildId: str, state: str, appInfo: map{appId: str?, name: str?, version: str?, buildNumber: int?, artifactType: str?, dateAdded: str(date-time)?, dateBuilt: str(date-time)?}, gitInfo: map?{headSha: str?, baseSha: str?, provider: str?, headRepoName: str?, baseRepoName: str?, headRef: str?, baseRef: str?, prNumber: int?}, platform: str?, projectId: str, projectSlug: str, buildConfiguration: str?, isInstallable: bool, installUrl: str(uri)?, installUrlExpiresAt: str(date-time)?, downloadCount: int, releaseNotes: str?, installGroups: [str]?, isCodeSignatureValid: bool?, profileName: str?, codesigningType: str?}
@errors {403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/preprodartifacts/{artifact_id}/size-analysis/
@required {artifact_id: str}
@optional {baseArtifactId: str}
@returns(200) {buildId: str, state: str, appInfo: map{appId: str?, name: str?, version: str?, buildNumber: int?, artifactType: str?, dateAdded: str(date-time)?, dateBuilt: str(date-time)?}, gitInfo: map?{headSha: str?, baseSha: str?, provider: str?, headRepoName: str?, baseRepoName: str?, headRef: str?, baseRef: str?, prNumber: int?}, errorCode: str?, errorMessage: str?, downloadSize: int?, installSize: int?, analysisDuration: num(double)?, analysisVersion: str?, baseBuildId: str?, baseAppInfo: map?{appId: str?, name: str?, version: str?, buildNumber: int?, artifactType: str?, dateAdded: str(date-time)?, dateBuilt: str(date-time)?}, insights: any, appComponents: [map]?, comparisons: [map]?}
@errors {400, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/preprodartifacts/snapshots/{snapshot_id}/
@required {snapshot_id: str}
@optional {compact_metadata: str}
@returns(200) {head_artifact_id: str, base_artifact_id: str?, project_id: str, comparison_type: str, state: str, vcs_info: map{head_sha: str?, base_sha: str?, provider: str?, head_repo_name: str?, base_repo_name: str?, head_ref: str?, base_ref: str?, pr_number: int?}, app_id: str?, is_selective: bool, images: [map], image_count: int, added: [map], added_count: int, removed: [map], removed_count: int, renamed: [map], renamed_count: int, changed: [map], changed_count: int, unchanged: [map], unchanged_count: int, errored: [map], errored_count: int, skipped: [map], skipped_count: int, diff_threshold: num(double)?, comparison_state: str?, approval_status: str?, comparison_error_message: str?, approvers: [map]}
@errors {403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/preprodartifacts/snapshots/{snapshot_id}/
@required {snapshot_id: str}
@returns(204)
@errors {400, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/preprodartifacts/snapshots/{snapshot_id}/archive/
@required {snapshot_id: str}
@returns(200) {ready: bool}
@errors {401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/preprodartifacts/snapshots/{snapshot_id}/archive/
@required {snapshot_id: str}
@returns(202) {detail: str}
@errors {401, 403, 404, 429}

@endpoint GET /organizations/{organization_id_or_slug}/preprodartifacts/snapshots/{snapshot_id}/images/{image_identifier}/
@required {snapshot_id: str, image_identifier: str}
@returns(200) {image_file_name: str, comparison_status: str?, head_image: map?{key: str, display_name: str?, group: str?, image_file_name: str, width: int, height: int, canvas_theme: str?, diff_threshold: num(double)?, description: str?, tags: map?, image_url: str}, base_image: map?{key: str, display_name: str?, group: str?, image_file_name: str, width: int, height: int, canvas_theme: str?, diff_threshold: num(double)?, description: str?, tags: map?, image_url: str}, diff_image_url: str?, diff_percentage: num(double)?, previous_image_file_name: str?}
@errors {403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/preprodartifacts/snapshots/latest-base/
@required {app_id: str}
@optional {branch: str, project: any, compact_metadata: str}
@returns(200) {head_artifact_id: str, project_id: str, project_slug: str, app_id: str?, image_count: int, images: [map], diff_threshold: num(double)?, date_added: str(date-time), vcs_info: map{head_sha: str?, base_sha: str?, head_ref: str?, base_ref: str?, head_repo_name: str?, pr_number: int?}}
@errors {400, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/profiling/chunks/
@required {project: str, profiler_id: str(uuid)}
@optional {statsPeriod: str, start: str(date-time), end: str(date-time)}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/profiling/flamegraph/
@optional {project: [any], environment: [str], statsPeriod: str, start: str(date-time), end: str(date-time), fingerprint: int(int64), dataSource: str(transactions/profiles/functions/spans), query: str, expand: [str]}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/project-keys/
@optional {cursor: str, team: str, status: str(active/inactive)}
@returns(200)
@errors {400, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/projects/
@optional {cursor: str, per_page: int, query: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/projects/
@required {name: str}
@optional {slug: str, platform: str, default_rules: bool}
@returns(201) {latestDeploys: map?, options: map, stats: any, transactionStats: [[int]], sessionStats: map{currentCrashFreeRate: num(double)?, previousCrashFreeRate: num(double)?, hasHealthData: bool}, id: str, slug: str, name: str, platform: str?, dateCreated: str(date-time), isBookmarked: bool, isMember: bool, features: [str], firstEvent: str(date-time)?, firstTransactionEvent: bool, access: [str], hasAccess: bool, hasFeedbacks: bool, hasFlags: bool, hasMinifiedStackTrace: bool, hasMonitors: bool, hasNewFeedbacks: bool, hasProfiles: bool, hasReplays: bool, hasSessions: bool, hasInsightsHttp: bool, hasInsightsDb: bool, hasInsightsAssets: bool, hasInsightsAppStart: bool, hasInsightsScreenLoad: bool, hasInsightsVitals: bool, hasInsightsCaches: bool, hasInsightsQueues: bool, hasInsightsAgentMonitoring: bool, hasInsightsMCP: bool, hasLogs: bool, hasTraceMetrics: bool, team: map?{id: str, name: str, slug: str}, teams: [map], platforms: [str], hasUserReports: bool, environments: [str], latestRelease: map?{version: str}}
@errors {400, 401, 403, 404, 409}

@endpoint POST /organizations/{organization_id_or_slug}/projects/{project_id_or_slug}/detectors/
@required {project_id_or_slug: str, name: str, type: str}
@optional {workflowIds: [int], dataSources: [any], config: map, conditionGroup: any, owner: str, description: str, enabled: bool}
@returns(201) {owner: map?{type: str, id: str, name: str, email: str}, createdBy: str?, latestGroup: map?{id: str, title: str, culprit: str?, shortId: str?, level: str, status: str, substatus: str?, platform: str?, project: map{id: str, name: str, slug: str, platform: str?}, type: str, issueType: str, issueCategory: str, metadata: map{title: str, value: str, type: str, synthetic: bool, filename: str, function: str, message: str, uri: str, directive: str, origin: str, name: str, contact_email: str, source: str, in_app_frame_mix: str, stripped_crash: bool, sdk: map{name: str, name_normalized: str}, severity: num(double), severity_reason: str, initial_priority: int}, numComments: int, firstSeen: str(date-time)?, lastSeen: str(date-time)?}, description: str?, id: str, projectId: str?, name: str, type: str, workflowIds: [str]?, dateCreated: str(date-time), dateUpdated: str(date-time), dataSources: [map]?, conditionGroup: map?{id: str, organizationId: str, logicType: str, conditions: [map], actions: [map]}, config: any, enabled: bool}
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/relay_usage/
@returns(200)
@errors {404}

@endpoint GET /organizations/{organization_id_or_slug}/release-threshold-statuses/
@required {start: str(date-time), end: str(date-time)}
@optional {environment: [str], projectSlug: [str], release: [str], project: [any]}
@returns(200)
@errors {400}

@endpoint GET /organizations/{organization_id_or_slug}/releases/
@optional {project: [any], environment: [str], query: str, per_page: int, cursor: str}
@returns(200)
@errors {401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/releases/
@required {version: str, projects: [str]}
@optional {ref: str, url: str(uri), dateReleased: str(date-time), commits: [map{id!: str, repository: str, message: str, author_name: str, author_email: str, timestamp: str(date-time), patch_set: [map]}], status: str, owner: str, headCommits: [map{currentId!: str, repository!: str, previousId: str}], refs: [map{commit!: str, repository!: str, previousCommit: str}]}
@returns(201) {ref: str?, url: str?, dateReleased: str(date-time)?, dateCreated: str(date-time)?, dateStarted: str(date-time)?, owner: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, lastCommit: map?{id: str, message: str?, dateCreated: str(date-time), pullRequest: map?{id: str, title: str?, message: str?, dateCreated: str(date-time), mergedAt: str(date-time)?, status: str?, repository: map{url: str?, provider: map, status: str, integrationId: str?, externalSlug: str?, externalId: str?, settings: map?, id: str, name: str, dateCreated: str(date-time)}, author: any, externalUrl: str?}, suspectCommitType: str, repository: map{url: str?, provider: map, status: str, integrationId: str?, externalSlug: str?, externalId: str?, settings: map?{enabledCodeReview: bool, codeReviewTriggers: [str]}, id: str, name: str, dateCreated: str(date-time)}, author: any}, lastDeploy: map?{dateStarted: str(date-time)?, url: str?, id: str, environment: str, dateFinished: str(date-time), name: str?}, firstEvent: str(date-time)?, lastEvent: str(date-time)?, currentProjectMeta: map?{sessionsLowerBound: str?, sessionsUpperBound: str?, nextReleaseVersion: str?, prevReleaseVersion: str?, firstReleaseVersion: str?, lastReleaseVersion: str?}, userAgent: str?, adoptionStages: map?, id: int, version: str, newGroups: int, status: str, shortVersion: str, versionInfo: map?{description: str, package: str?, version: map{major: int, minor: int, patch: int, pre: str?, buildCode: str?, components: int, raw: str}, buildHash: str?}, data: map, commitCount: int, deployCount: int, authors: [any], projects: [map]}
@returns(208)
@errors {400, 401, 403}

@endpoint GET /organizations/{organization_id_or_slug}/releases/{version}/
@required {version: str}
@optional {project_id: str, project: any, health: bool, adoptionStages: bool, summaryStatsPeriod: str(14d/1d/1h/24h/2d/30d/48h/7d/90d), healthStatsPeriod: str(14d/1d/1h/24h/2d/30d/48h/7d/90d), sort: str, status: str(archived/open), query: str}
@returns(200) {ref: str?, url: str?, dateReleased: str(date-time)?, dateCreated: str(date-time)?, dateStarted: str(date-time)?, owner: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, lastCommit: map?{id: str, message: str?, dateCreated: str(date-time), pullRequest: map?{id: str, title: str?, message: str?, dateCreated: str(date-time), mergedAt: str(date-time)?, status: str?, repository: map{url: str?, provider: map, status: str, integrationId: str?, externalSlug: str?, externalId: str?, settings: map?, id: str, name: str, dateCreated: str(date-time)}, author: any, externalUrl: str?}, suspectCommitType: str, repository: map{url: str?, provider: map, status: str, integrationId: str?, externalSlug: str?, externalId: str?, settings: map?{enabledCodeReview: bool, codeReviewTriggers: [str]}, id: str, name: str, dateCreated: str(date-time)}, author: any}, lastDeploy: map?{dateStarted: str(date-time)?, url: str?, id: str, environment: str, dateFinished: str(date-time), name: str?}, firstEvent: str(date-time)?, lastEvent: str(date-time)?, currentProjectMeta: map?{sessionsLowerBound: str?, sessionsUpperBound: str?, nextReleaseVersion: str?, prevReleaseVersion: str?, firstReleaseVersion: str?, lastReleaseVersion: str?}, userAgent: str?, adoptionStages: map?, id: int, version: str, newGroups: int, status: str, shortVersion: str, versionInfo: map?{description: str, package: str?, version: map{major: int, minor: int, patch: int, pre: str?, buildCode: str?, components: int, raw: str}, buildHash: str?}, data: map, commitCount: int, deployCount: int, authors: [any], projects: [map]}
@errors {400, 401, 403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/releases/{version}/
@required {version: str}
@optional {ref: str, url: str(uri), dateReleased: str(date-time), commits: [map{id!: str, repository: str, message: str, author_name: str, author_email: str, timestamp: str(date-time), patch_set: [map]}], status: str, headCommits: [map{currentId!: str, repository!: str, previousId: str}], refs: [map{commit!: str, repository!: str, previousCommit: str}]}
@returns(200) {ref: str?, url: str?, dateReleased: str(date-time)?, dateCreated: str(date-time)?, dateStarted: str(date-time)?, owner: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, lastCommit: map?{id: str, message: str?, dateCreated: str(date-time), pullRequest: map?{id: str, title: str?, message: str?, dateCreated: str(date-time), mergedAt: str(date-time)?, status: str?, repository: map{url: str?, provider: map, status: str, integrationId: str?, externalSlug: str?, externalId: str?, settings: map?, id: str, name: str, dateCreated: str(date-time)}, author: any, externalUrl: str?}, suspectCommitType: str, repository: map{url: str?, provider: map, status: str, integrationId: str?, externalSlug: str?, externalId: str?, settings: map?{enabledCodeReview: bool, codeReviewTriggers: [str]}, id: str, name: str, dateCreated: str(date-time)}, author: any}, lastDeploy: map?{dateStarted: str(date-time)?, url: str?, id: str, environment: str, dateFinished: str(date-time), name: str?}, firstEvent: str(date-time)?, lastEvent: str(date-time)?, currentProjectMeta: map?{sessionsLowerBound: str?, sessionsUpperBound: str?, nextReleaseVersion: str?, prevReleaseVersion: str?, firstReleaseVersion: str?, lastReleaseVersion: str?}, userAgent: str?, adoptionStages: map?, id: int, version: str, newGroups: int, status: str, shortVersion: str, versionInfo: map?{description: str, package: str?, version: map{major: int, minor: int, patch: int, pre: str?, buildCode: str?, components: int, raw: str}, buildHash: str?}, data: map, commitCount: int, deployCount: int, authors: [any], projects: [map]}
@errors {400, 401, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/releases/{version}/
@required {version: str}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/releases/{version}/commits/
@required {version: str}
@optional {cursor: str}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/releases/{version}/deploys/
@required {version: str}
@optional {cursor: str}
@returns(200)

@endpoint POST /organizations/{organization_id_or_slug}/releases/{version}/deploys/
@required {version: str, environment: str}
@optional {name: str, url: str(uri), dateStarted: str(date-time), dateFinished: str(date-time), projects: [str]}
@returns(201) {id: str, environment: str, dateStarted: str(date-time)?, dateFinished: str(date-time), name: str?, url: str(uri)?}
@errors {400}

@endpoint GET /organizations/{organization_id_or_slug}/releases/{version}/files/
@required {version: str}
@optional {query: [str], checksum: [str], cursor: str}
@returns(200)
@errors {401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/releases/{version}/files/
@required {version: str}
@returns(201) {id: any, name: str, dist: str?, headers: map, size: int?, sha1: str?, dateCreated: str(date-time)}
@errors {400, 401, 403, 404, 409}

@endpoint GET /organizations/{organization_id_or_slug}/releases/{version}/files/{file_id}/
@required {version: str, file_id: str}
@optional {download: str}
@returns(200) {id: any, name: str, dist: str?, headers: map, size: int?, sha1: str?, dateCreated: str(date-time)}
@errors {401, 403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/releases/{version}/files/{file_id}/
@required {version: str, file_id: str, name: str}
@returns(200) {id: any, name: str, dist: str?, headers: map, size: int?, sha1: str?, dateCreated: str(date-time)}
@errors {400, 401, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/releases/{version}/files/{file_id}/
@required {version: str, file_id: str}
@returns(204)
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/releases/{version}/previous-with-commits/
@required {version: str}
@optional {project: [any]}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/replay-count/
@required {query: str, data_source: str(errors/search_issues/spans)}
@optional {environment: [str], start: str(date-time), end: str(date-time), statsPeriod: str, project: [any], project_id_or_slug: [str], returnIds: bool=false}
@returns(200)
@errors {400, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/replay-selectors/
@optional {environment: [str], statsPeriod: str, start: str(date-time), end: str(date-time), project: [any], projectSlug: [str], sort: str, sortBy: str, orderBy: str, cursor: str, per_page: int, query: str}
@returns(200) {data: [map]}
@errors {400, 403}

@endpoint GET /organizations/{organization_id_or_slug}/replays/
@optional {statsPeriod: str, start: str(date-time), end: str(date-time), field: [str], project: [any], projectSlug: [str], environment: [str], sort: str, sortBy: str, orderBy: str, query: str, queryReferrer: str, per_page: int, cursor: str}
@returns(200) {data: [map]}
@errors {400, 403}

@endpoint GET /organizations/{organization_id_or_slug}/replays/{replay_id}/
@required {replay_id: str}
@optional {statsPeriod: str, start: str(date-time), end: str(date-time), field: [str], project: [any], projectSlug: [str], environment: [str], sort: str, sortBy: str, orderBy: str, query: str, queryReferrer: str, per_page: int, cursor: str}
@returns(200) {data: map{id: str, project_id: str, trace_ids: [str], error_ids: [str], environment: str?, tags: any, user: map{id: str?, username: str?, email: str?, ip: str?, display_name: str?, geo: map{city: str?, country_code: str?, region: str?, subdivision: str?}}, sdk: map{name: str?, version: str?}, os: map{name: str?, version: str?}, browser: map{name: str?, version: str?}, device: map{name: str?, brand: str?, model: str?, family: str?}, ota_updates: map{channel: str?, runtime_version: str?, update_id: str?}, is_archived: bool?, urls: [str]?, segment_names: [str]?, clicks: [map], count_dead_clicks: int?, count_rage_clicks: int?, count_errors: int?, duration: int?, finished_at: str?, started_at: str?, activity: int?, count_urls: int?, replay_type: str, count_segments: int?, platform: str?, releases: [str], dist: str?, count_warnings: int?, count_infos: int?, has_viewed: bool}}
@errors {400, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/repos/
@optional {query: str, status: str(active/deleted), integration_id: str, expand: [str], cursor: str, per_page: int}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/repos/{repo_id}/commits/
@required {repo_id: str}
@optional {cursor: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/repos/settings/
@required {repositoryIds: [int]}
@optional {enabledCodeReview: bool, codeReviewTriggers: [str]}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/scim/v2/Groups
@optional {startIndex: int=1, count: int=100, filter: str, excludedAttributes: [str]}
@returns(200) {schemas: [str], totalResults: int, startIndex: int, itemsPerPage: int, Resources: [map]}
@errors {401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/scim/v2/Groups
@required {displayName: str}
@returns(201) {schemas: [str], id: str, displayName: str, meta: map{resourceType: str}, members: [map]}
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/scim/v2/Groups/{team_id_or_slug}
@required {team_id_or_slug: str}
@returns(200) {schemas: [str], id: str, displayName: str, meta: map{resourceType: str}, members: [map]}
@errors {401, 403, 404}

@endpoint PATCH /organizations/{organization_id_or_slug}/scim/v2/Groups/{team_id_or_slug}
@required {team_id_or_slug: str, schemas: [str], Operations: [map{op!: str, value: map, path: str}]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/scim/v2/Groups/{team_id_or_slug}
@required {team_id_or_slug: str}
@returns(204)
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/scim/v2/ResourceTypes
@returns(200) {schemas: [str], totalResults: int, startIndex: int, itemsPerPage: int, Resources: [map]}
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/scim/v2/ResourceTypes/{resource_type_name}
@required {resource_type_name: str}
@returns(200) {schemas: [str], id: str, name: str, description: str, endpoint: str, schema: str, meta: map{resourceType: str, location: str}}
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/scim/v2/Schemas/{schema_uri}
@required {schema_uri: str}
@returns(200) {schemas: [str], id: str, name: str, description: str, attributes: [map], meta: map{resourceType: str, location: str}}
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/scim/v2/ServiceProviderConfig
@returns(200) {schemas: [str], documentationUri: str, patch: map{supported: bool}, bulk: map{supported: bool, maxOperations: int, maxPayloadSize: int}, filter: map{supported: bool, maxResults: int}, changePassword: map{supported: bool}, sort: map{supported: bool}, etag: map{supported: bool}, authenticationSchemes: [map], meta: map{resourceType: str, location: str}}
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/scim/v2/Users
@optional {startIndex: int=1, count: int=100, filter: str, excludedAttributes: [str]}
@returns(200) {schemas: [str], totalResults: int, startIndex: int, itemsPerPage: int, Resources: [map]}
@errors {401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/scim/v2/Users
@required {userName: str(email)}
@optional {sentryOrgRole: str(billing/member/manager/admin)}
@returns(201) {active: bool, schemas: [str], id: str, userName: str, name: map{givenName: str, familyName: str}, emails: [map], meta: map{resourceType: str}, sentryOrgRole: str}
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/scim/v2/Users/{member_id}
@required {member_id: str}
@returns(200) {active: bool, schemas: [str], id: str, userName: str, name: map{givenName: str, familyName: str}, emails: [map], meta: map{resourceType: str}, sentryOrgRole: str}
@errors {401, 403, 404}

@endpoint PATCH /organizations/{organization_id_or_slug}/scim/v2/Users/{member_id}
@required {member_id: str, Operations: [map{op!: str, value!: any, path: str}]}
@optional {schemas: [str]}
@returns(204)
@errors {401, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/scim/v2/Users/{member_id}
@required {member_id: str}
@returns(204)
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/sentry-app-components/
@optional {cursor: str, filter: str}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/sentry-apps/
@returns(200)

@endpoint GET /organizations/{organization_id_or_slug}/sessions/
@required {field: [str]}
@optional {start: str(date-time), end: str(date-time), environment: [str], statsPeriod: str, project: [any], per_page: int, interval: str, groupBy: [str], orderBy: str, includeTotals: int, includeSeries: int, query: str}
@returns(200) {start: str(date-time), end: str(date-time), intervals: [str], groups: [map], query: str}
@errors {400, 401}

@endpoint GET /organizations/{organization_id_or_slug}/shortids/{issue_id}/
@required {issue_id: str}
@optional {collapse: [str]}
@returns(200) {organizationSlug: str, projectSlug: str, groupId: str, group: map{isUnhandled: bool, count: str, userCount: int, firstSeen: str(date-time)?, lastSeen: str(date-time)?, derivedData: map{blocker: str, progress: str, status: str, viewCount: int, hasOpenFixPr: bool, isAssigned: bool, hasRootCause: bool, lastCompletedAutofixStep: str, lastProgressedAt: str(date-time)?, impact: map?{score: num(double)?, level: str?, description: str, citations: [map], sourceEventId: str}}, id: str, shareId: str?, shortId: str?, title: str, culprit: str?, permalink: str(uri), logger: str?, level: str, status: str, statusDetails: map{ignoreCount: int?, ignoreUntil: str(date-time)?, ignoreUserCount: int?, ignoreUserWindow: int?, ignoreWindow: int?, actor: map?{identities: [map], avatar: map, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, inNextRelease: bool, inRelease: str, inCommit: str, pendingEvents: int, info: map?{dateCreated: str, syncCount: int, totalEvents: int}}, substatus: str?, isPublic: bool, platform: str?, priority: str?, priorityLockedAt: str(date-time)?, seerFixabilityScore: num(double)?, seerAutofixLastTriggered: str(date-time)?, seerExplorerAutofixLastTriggered: str(date-time)?, project: map{id: str, name: str, slug: str, platform: str?}, type: str, issueType: str, issueCategory: str, metadata: map{title: str, value: str, type: str, synthetic: bool, filename: str, function: str, message: str, uri: str, directive: str, origin: str, name: str, contact_email: str, source: str, in_app_frame_mix: str, stripped_crash: bool, sdk: map{name: str, name_normalized: str}, severity: num(double), severity_reason: str, initial_priority: int}, numComments: int, assignedTo: map?{type: str, id: str, name: str, email: str}, isBookmarked: bool, isSubscribed: bool, subscriptionDetails: map?{disabled: bool, reason: str}, hasSeen: bool, annotations: [map]}, shortId: str}
@errors {400, 401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/starred-service-spans/
@required {service_span: str, project_id: int}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/starred-service-spans/
@required {service_span: str, project_id: int}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/stats-summary/
@required {field: str(sum(quantity)/sum(times_seen))}
@optional {statsPeriod: str, interval: str, start: str(date-time), end: str(date-time), project: [any], category: str(error/transaction/attachment/replays/profiles), outcome: str(accepted/filtered/rate_limited/invalid/abuse/client_discard/cardinality_limited), reason: str, download: bool}
@returns(200) {start: str, end: str, projects: [map]}
@errors {401, 404}

@endpoint GET /organizations/{organization_id_or_slug}/stats_v2/
@required {groupBy: [str], field: str(sum(quantity)/sum(times_seen))}
@optional {statsPeriod: str, interval: str, start: str(date-time), end: str(date-time), project: [any], category: str(error/transaction/attachment/replay/profile/profile_duration/profile_duration_ui/profile_chunk/profile_chunk_ui/monitor), outcome: str(accepted/filtered/rate_limited/invalid/abuse/client_discard/cardinality_limited), reason: str}
@returns(200) {start: str, end: str, intervals: [str], groups: [map]}
@errors {401, 404}

@endpoint GET /organizations/{organization_id_or_slug}/tags/
@optional {project: [any], environment: [str], statsPeriod: str, start: str(date-time), end: str(date-time), dataset: str(discover/events/replays/search_issues), use_cache: str(0/1), useFlagsBackend: str(0/1)}
@returns(200)
@errors {400, 401, 403}

@endpoint GET /organizations/{organization_id_or_slug}/teams/
@optional {detailed: str, cursor: str, per_page: int, query: str}
@returns(200)
@errors {403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/teams/
@optional {slug: str, name: str}
@returns(201) {id: str, slug: str, name: str, dateCreated: str(date-time)?, isMember: bool, teamRole: str?, flags: map, access: [str], hasAccess: bool, isPending: bool, memberCount: int, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, externalTeams: [map], organization: map{features: [str], extraOptions: map, access: [str], onboardingTasks: [map], id: str, slug: str, status: map{id: str, name: str}, name: str, dateCreated: str(date-time), isEarlyAdopter: bool, require2FA: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, links: map{organizationUrl: str, regionUrl: str}, hasAuthProvider: bool, allowMemberInvite: bool, allowMemberProjectCreation: bool, allowSuperuserAccess: bool}, projects: [map]}
@errors {400, 403, 404, 409}

@endpoint GET /organizations/{organization_id_or_slug}/trace-items/attributes/
@optional {statsPeriod: str, start: str(date-time), end: str(date-time), environment: [str], project: [any], dataset: str(logs/preprod/processing_errors/spans/tracemetrics), itemType: str(logs/preprod/processing_errors/spans/tracemetrics), attributeType: [str], substringMatch: str, query: str, expand: [str], cursor: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/trace-items/metrics/
@optional {project: [any], environment: [str], statsPeriod: str, start: str(date-time), end: str(date-time), query: str, sort: str(-count/-lastSeen/-name/-type/-unit/count/lastSeen/name/type/unit), expand: [str], contextOnly: bool}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/trace-items/stats/
@required {statsType: [str]}
@optional {project: [any], environment: [str], statsPeriod: str, start: str(date-time), end: str(date-time), query: str, substringMatch: str, traceItemsLimit: int=1000, itemType: str(spans/occurrences)=spans, cursor: str}
@returns(200) {data: [map]}
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/trace-logs/
@optional {statsPeriod: str, start: str(date-time), end: str(date-time), traceId: [str], replayId: str, query: str, sort: [str], timestamp: str, per_page: int, cursor: str}
@returns(200) {data: [map], meta: map{fields: map, full_scan: bool, bytes_scanned: int?, routingHint: str}, confidence: [map]}
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/trace-meta/{trace_id}/
@required {trace_id: str}
@optional {statsPeriod: str, start: str(date-time), end: str(date-time), timestamp: str, include_uptime: str(0/1)}
@returns(200) {uptimeCount: int, errorsCount: int, logsCount: num(double), metricsCount: num(double), performanceIssuesCount: int, spansCount: num(double), transactionChildCountMap: [map], spansCountMap: map}
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/trace/{trace_id}/
@required {trace_id: str}
@optional {statsPeriod: str, start: str(date-time), end: str(date-time), referrer: str, timestamp: str, errorId: str, additional_attributes: [str], include_uptime: str(0/1)}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/user-teams/
@returns(200)
@errors {400, 403}

@endpoint GET /organizations/{organization_id_or_slug}/workflows/
@optional {sortBy: str, query: str, id: [int], detector: [int], type: [str], project: [any], per_page: int, cursor: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/workflows/
@required {name: str}
@optional {id: str, enabled: bool=true, detectorIds: [int], config: map, environment: str, triggers: any, actionFilters: [map{id: int, logicType!: str, conditions: [any], actions!: [any]}], owner: str}
@returns(201) {id: str, name: str, type: str, organizationId: str, createdBy: str?, dateCreated: str(date-time), dateUpdated: str(date-time), triggers: map?{id: str, organizationId: str, logicType: str, conditions: [map], actions: [map]}, actionFilters: [map]?, environment: str?, config: map{frequency: int}, detectorIds: [str]?, enabled: bool, lastTriggered: str(date-time)?, owner: str?}
@errors {400, 401, 403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/workflows/
@required {enabled: bool}
@optional {query: str, id: [int], project: [any]}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/workflows/
@optional {query: str, id: [int], project: [any]}
@returns(200)
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/workflows/{workflow_id}/
@required {workflow_id: int}
@returns(200) {id: str, name: str, type: str, organizationId: str, createdBy: str?, dateCreated: str(date-time), dateUpdated: str(date-time), triggers: map?{id: str, organizationId: str, logicType: str, conditions: [map], actions: [map]}, actionFilters: [map]?, environment: str?, config: map{frequency: int}, detectorIds: [str]?, enabled: bool, lastTriggered: str(date-time)?, owner: str?}
@errors {400, 401, 403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/workflows/{workflow_id}/
@required {workflow_id: int, name: str}
@optional {id: str, enabled: bool=true, detectorIds: [int], config: map, environment: str, triggers: any, actionFilters: [map{id: int, logicType!: str, conditions: [any], actions!: [any]}], owner: str}
@returns(200) {id: str, name: str, type: str, organizationId: str, createdBy: str?, dateCreated: str(date-time), dateUpdated: str(date-time), triggers: map?{id: str, organizationId: str, logicType: str, conditions: [map], actions: [map]}, actionFilters: [map]?, environment: str?, config: map{frequency: int}, detectorIds: [str]?, enabled: bool, lastTriggered: str(date-time)?, owner: str?}
@errors {400, 401, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/workflows/{workflow_id}/
@required {workflow_id: int}
@returns(204)
@errors {400, 401, 403, 404}

@endgroup

@group projects
@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/
@required {project_id_or_slug: str}
@returns(200) {stats: any, transactionStats: [[int]], sessionStats: map{currentCrashFreeRate: num(double)?, previousCrashFreeRate: num(double)?, hasHealthData: bool}, id: str, slug: str, name: str, platform: str?, dateCreated: str(date-time), isBookmarked: bool, isMember: bool, features: [str], firstEvent: str(date-time)?, firstTransactionEvent: bool, access: [str], hasAccess: bool, hasFeedbacks: bool, hasFlags: bool, hasMinifiedStackTrace: bool, hasMonitors: bool, hasNewFeedbacks: bool, hasProfiles: bool, hasReplays: bool, hasSessions: bool, hasInsightsHttp: bool, hasInsightsDb: bool, hasInsightsAssets: bool, hasInsightsAppStart: bool, hasInsightsScreenLoad: bool, hasInsightsVitals: bool, hasInsightsCaches: bool, hasInsightsQueues: bool, hasInsightsAgentMonitoring: bool, hasInsightsMCP: bool, hasLogs: bool, hasTraceMetrics: bool, isInternal: bool, isPublic: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, color: str, status: str, team: map{id: str, name: str, slug: str}, teams: [map], latestRelease: map?{version: str}, options: map, digestsMinDelay: int, digestsMaxDelay: int, subjectPrefix: str, allowedDomains: [str], resolveAge: int, dataScrubber: bool, dataScrubberDefaults: bool, safeFields: [str], storeCrashReports: int?, sensitiveFields: [str], subjectTemplate: str, securityToken: str, securityTokenHeader: str?, verifySSL: bool, scrubIPAddresses: bool, scrapeJavaScript: bool, enableAutoReleaseCreation: bool, highlightTags: [str], highlightContext: map, highlightPreset: map{tags: [str], context: map}, groupingConfig: str, derivedGroupingEnhancements: str, groupingEnhancements: str, secondaryGroupingExpiry: int, secondaryGroupingConfig: str?, fingerprintingRules: str, organization: map{features: [str], extraOptions: map, access: [str], onboardingTasks: [map], id: str, slug: str, status: map{id: str, name: str}, name: str, dateCreated: str(date-time), isEarlyAdopter: bool, require2FA: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, links: map{organizationUrl: str, regionUrl: str}, hasAuthProvider: bool, allowMemberInvite: bool, allowMemberProjectCreation: bool, allowSuperuserAccess: bool}, platforms: [str], processingIssues: int, defaultEnvironment: str?, relayPiiConfig: str?, builtinSymbolSources: [str], enableNativeSourceServerMapping: bool, dynamicSamplingBiases: [map]?, symbolSources: str, isDynamicallySampled: bool, tempestFetchScreenshots: bool, autofixAutomationTuning: str, seerScannerAutomation: bool, seerNightshiftTweaks: any, scmSourceContextEnabled: bool, debugFilesRole: str?}
@errors {400, 403, 404}

@endpoint PUT /projects/{organization_id_or_slug}/{project_id_or_slug}/
@required {project_id_or_slug: str, digestsMinDelay: int, digestsMaxDelay: int, securityToken: str, securityTokenHeader: str}
@optional {isBookmarked: bool, autofixAutomationTuning: str(off/super_low/low/medium/high/always), seerScannerAutomation: bool, preprodSizeStatusChecksEnabled: bool, preprodSizeStatusChecksRules: map, preprodSizePrCommentsEnabled: bool, preprodSizePrCommentsRules: map, preprodSnapshotStatusChecksEnabled: bool, preprodSnapshotStatusChecksFailOnAdded: bool, preprodSnapshotStatusChecksFailOnRemoved: bool, preprodSnapshotStatusChecksFailOnChanged: bool, preprodSnapshotStatusChecksFailOnRenamed: bool, preprodSizeEnabledByCustomer: bool, preprodDistributionEnabledByCustomer: bool, preprodDistributionPrCommentsEnabledByCustomer: bool, preprodSnapshotPrCommentsEnabled: bool, preprodSnapshotPrCommentsPostOnAdded: bool, preprodSnapshotPrCommentsPostOnRemoved: bool, preprodSnapshotPrCommentsPostOnChanged: bool, preprodSnapshotPrCommentsPostOnRenamed: bool, preprodSizeEnabledQuery: str, preprodDistributionEnabledQuery: str, name: str, slug: str, platform: str, subjectPrefix: str, subjectTemplate: str, resolveAge: int, highlightContext: map, highlightTags: [str], verifySSL: bool, defaultEnvironment: str, dataScrubber: bool, dataScrubberDefaults: bool, sensitiveFields: [str], safeFields: [str], storeCrashReports: int, relayPiiConfig: str, builtinSymbolSources: [str], symbolSources: str, enableNativeSourceServerMapping: bool, scrubIPAddresses: bool, groupingConfig: str, groupingEnhancements: str, fingerprintingRules: str, secondaryGroupingConfig: str, secondaryGroupingExpiry: int, scrapeJavaScript: bool, enableAutoReleaseCreation: bool, allowedDomains: [str], copy_from_project: int, dynamicSamplingBiases: [map{id!: str, active: bool}], tempestFetchScreenshots: bool, scmSourceContextEnabled: bool, debugFilesRole: str(member/admin/manager/owner)}
@returns(200) {stats: any, transactionStats: [[int]], sessionStats: map{currentCrashFreeRate: num(double)?, previousCrashFreeRate: num(double)?, hasHealthData: bool}, id: str, slug: str, name: str, platform: str?, dateCreated: str(date-time), isBookmarked: bool, isMember: bool, features: [str], firstEvent: str(date-time)?, firstTransactionEvent: bool, access: [str], hasAccess: bool, hasFeedbacks: bool, hasFlags: bool, hasMinifiedStackTrace: bool, hasMonitors: bool, hasNewFeedbacks: bool, hasProfiles: bool, hasReplays: bool, hasSessions: bool, hasInsightsHttp: bool, hasInsightsDb: bool, hasInsightsAssets: bool, hasInsightsAppStart: bool, hasInsightsScreenLoad: bool, hasInsightsVitals: bool, hasInsightsCaches: bool, hasInsightsQueues: bool, hasInsightsAgentMonitoring: bool, hasInsightsMCP: bool, hasLogs: bool, hasTraceMetrics: bool, isInternal: bool, isPublic: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, color: str, status: str, team: map{id: str, name: str, slug: str}, teams: [map], latestRelease: map?{version: str}, options: map, digestsMinDelay: int, digestsMaxDelay: int, subjectPrefix: str, allowedDomains: [str], resolveAge: int, dataScrubber: bool, dataScrubberDefaults: bool, safeFields: [str], storeCrashReports: int?, sensitiveFields: [str], subjectTemplate: str, securityToken: str, securityTokenHeader: str?, verifySSL: bool, scrubIPAddresses: bool, scrapeJavaScript: bool, enableAutoReleaseCreation: bool, highlightTags: [str], highlightContext: map, highlightPreset: map{tags: [str], context: map}, groupingConfig: str, derivedGroupingEnhancements: str, groupingEnhancements: str, secondaryGroupingExpiry: int, secondaryGroupingConfig: str?, fingerprintingRules: str, organization: map{features: [str], extraOptions: map, access: [str], onboardingTasks: [map], id: str, slug: str, status: map{id: str, name: str}, name: str, dateCreated: str(date-time), isEarlyAdopter: bool, require2FA: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, links: map{organizationUrl: str, regionUrl: str}, hasAuthProvider: bool, allowMemberInvite: bool, allowMemberProjectCreation: bool, allowSuperuserAccess: bool}, platforms: [str], processingIssues: int, defaultEnvironment: str?, relayPiiConfig: str?, builtinSymbolSources: [str], enableNativeSourceServerMapping: bool, dynamicSamplingBiases: [map]?, symbolSources: str, isDynamicallySampled: bool, tempestFetchScreenshots: bool, autofixAutomationTuning: str, seerScannerAutomation: bool, seerNightshiftTweaks: any, scmSourceContextEnabled: bool, debugFilesRole: str?}
@errors {400, 403, 404, 409}

@endpoint DELETE /projects/{organization_id_or_slug}/{project_id_or_slug}/
@required {project_id_or_slug: str}
@returns(204)
@errors {403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/code-mapping-prefixes/stack/
@required {project_id_or_slug: str}
@returns(200) {prefixes: [map]}
@errors {401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/codeowners/
@required {project_id_or_slug: str}
@optional {expand: [str]}
@returns(200)
@errors {401, 403, 404}

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/codeowners/
@required {project_id_or_slug: str, raw: str, codeMappingId: str}
@returns(201) {codeMapping: map{id: str, projectId: str, projectSlug: str, repoId: str, repoName: str, integrationId: str?, provider: map?{key: str, slug: str, name: str, canAdd: bool, canDisable: bool, features: [str], aspects: map{alerts: [map], configure_integration: map, directEnable: bool, disable_dialog: map, externalInstall: map, removal_dialog: map}}, stackRoot: str, sourceRoot: str, defaultBranch: str?, automaticallyGenerated: bool, hasCodeOwner: bool}, ownershipSyntax: str, errors: map{missing_user_emails: [str], missing_external_users: [str], missing_external_teams: [str], teams_without_access: [str], users_without_access: [str]}, schema: any, codeOwnersUrl: str, id: str, raw: str, dateCreated: str(date-time), dateUpdated: str(date-time), dateSynced: str(date-time)?, codeMappingId: str, provider: str}
@errors {400, 401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/codeowners/{codeowners_id}/
@required {project_id_or_slug: str, codeowners_id: str}
@returns(200) {codeMapping: map{id: str, projectId: str, projectSlug: str, repoId: str, repoName: str, integrationId: str?, provider: map?{key: str, slug: str, name: str, canAdd: bool, canDisable: bool, features: [str], aspects: map{alerts: [map], configure_integration: map, directEnable: bool, disable_dialog: map, externalInstall: map, removal_dialog: map}}, stackRoot: str, sourceRoot: str, defaultBranch: str?, automaticallyGenerated: bool, hasCodeOwner: bool}, ownershipSyntax: str, errors: map{missing_user_emails: [str], missing_external_users: [str], missing_external_teams: [str], teams_without_access: [str], users_without_access: [str]}, schema: any, codeOwnersUrl: str, id: str, raw: str, dateCreated: str(date-time), dateUpdated: str(date-time), dateSynced: str(date-time)?, codeMappingId: str, provider: str}
@errors {401, 403, 404}

@endpoint PUT /projects/{organization_id_or_slug}/{project_id_or_slug}/codeowners/{codeowners_id}/
@required {project_id_or_slug: str, codeowners_id: str}
@optional {raw: str, codeMappingId: str}
@returns(200) {codeMapping: map{id: str, projectId: str, projectSlug: str, repoId: str, repoName: str, integrationId: str?, provider: map?{key: str, slug: str, name: str, canAdd: bool, canDisable: bool, features: [str], aspects: map{alerts: [map], configure_integration: map, directEnable: bool, disable_dialog: map, externalInstall: map, removal_dialog: map}}, stackRoot: str, sourceRoot: str, defaultBranch: str?, automaticallyGenerated: bool, hasCodeOwner: bool}, ownershipSyntax: str, errors: map{missing_user_emails: [str], missing_external_users: [str], missing_external_teams: [str], teams_without_access: [str], users_without_access: [str]}, schema: any, codeOwnersUrl: str, id: str, raw: str, dateCreated: str(date-time), dateUpdated: str(date-time), dateSynced: str(date-time)?, codeMappingId: str, provider: str}
@errors {400, 401, 403, 404}

@endpoint DELETE /projects/{organization_id_or_slug}/{project_id_or_slug}/codeowners/{codeowners_id}/
@required {project_id_or_slug: str, codeowners_id: str}
@returns(204)
@errors {401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/custom-inbound-filters/
@required {project_id_or_slug: str}
@returns(200)
@errors {400, 403, 404}

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/custom-inbound-filters/
@required {project_id_or_slug: str, id: str, dataType: str(all/error/log/metric/span), conditions: [map{type!: str, operator: str, value!: [str]}], dateCreated: str(date-time), dateUpdated: str(date-time), legacyFilter: str}
@optional {name: str, active: bool}
@returns(201) {id: str, dataType: str, conditions: [map], dateCreated: str(date-time), dateUpdated: str(date-time), legacyFilter: str?, name: str?, active: bool}
@errors {400, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/custom-inbound-filters/{filter_id}/
@required {project_id_or_slug: str, filter_id: str}
@returns(200) {id: str, dataType: str, conditions: [map], dateCreated: str(date-time), dateUpdated: str(date-time), legacyFilter: str?, name: str?, active: bool}
@errors {400, 403, 404}

@endpoint PUT /projects/{organization_id_or_slug}/{project_id_or_slug}/custom-inbound-filters/{filter_id}/
@required {project_id_or_slug: str, filter_id: str, id: str, dataType: str(all/error/log/metric/span), conditions: [map{type!: str, operator: str, value!: [str]}], dateCreated: str(date-time), dateUpdated: str(date-time), legacyFilter: str}
@optional {name: str, active: bool}
@returns(200) {id: str, dataType: str, conditions: [map], dateCreated: str(date-time), dateUpdated: str(date-time), legacyFilter: str?, name: str?, active: bool}
@errors {400, 403, 404}

@endpoint DELETE /projects/{organization_id_or_slug}/{project_id_or_slug}/custom-inbound-filters/{filter_id}/
@required {project_id_or_slug: str, filter_id: str}
@returns(204)
@errors {400, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/environments/
@required {project_id_or_slug: str}
@optional {visibility: str(all/hidden/visible)=visible}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint PUT /projects/{organization_id_or_slug}/{project_id_or_slug}/environments/
@required {project_id_or_slug: str, environmentNames: [str], isHidden: bool}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/environments/{environment}/
@required {project_id_or_slug: str, environment: str}
@returns(200) {id: str, name: str, isHidden: bool}
@errors {401, 403, 404}

@endpoint PUT /projects/{organization_id_or_slug}/{project_id_or_slug}/environments/{environment}/
@required {project_id_or_slug: str, environment: str, isHidden: bool}
@returns(200) {id: str, name: str, isHidden: bool}
@errors {400, 401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/events/
@required {project_id_or_slug: str}
@optional {statsPeriod: str, statsPeriodStart: str, statsPeriodEnd: str, start: str(date-time), end: str(date-time), cursor: str, full: bool=false, sample: bool=false}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/events/{event_id}/
@required {project_id_or_slug: str, event_id: str}
@optional {environment: [str], start: str(date-time), end: str(date-time), statsPeriod: str, statsPeriodStart: str, statsPeriodEnd: str, collapse: [str]}
@returns(200) {id: str, groupID: str?, eventID: str, projectID: str, message: str?, title: str, location: str?, platform: str?, dateReceived: str(date-time)?, size: int?, entries: [any], dist: str?, packages: map, type: str, metadata: map{title: str, value: str, type: str, synthetic: bool, filename: str, function: str, message: str, uri: str, directive: str, origin: str, name: str, contact_email: str, source: str, in_app_frame_mix: str, stripped_crash: bool, sdk: map{name: str, name_normalized: str}, severity: num(double), severity_reason: str, initial_priority: int}, occurrence: any, _meta: map, user: map?{id: str?, email: str?, username: str?, ip_address: str?, name: str?, geo: map?, data: map?}, tags: [map], contexts: map?, sdk: map?{name: str?, version: str?}, context: map?, errors: [map], crashFile: str?, culprit: str?, dateCreated: str(date-time), fingerprints: [str], groupingConfig: map{id: str, enhancements: str}, startTimestamp: num(double), endTimestamp: num(double), measurements: map?, breakdowns: map?, release: map?{id: int, commitCount: int, data: map, dateCreated: str(date-time), dateReleased: str(date-time)?, deployCount: int, ref: str?, lastCommit: map?{id: str, message: str?, dateCreated: str(date-time), pullRequest: map?{id: str, title: str?, message: str?, dateCreated: str(date-time), mergedAt: str(date-time)?, status: str?, repository: map, author: any, externalUrl: str?}, suspectCommitType: str, repository: map{url: str?, provider: map, status: str, integrationId: str?, externalSlug: str?, externalId: str?, settings: map?, id: str, name: str, dateCreated: str(date-time)}, author: any}, lastDeploy: map?{dateStarted: str(date-time)?, url: str?, id: str, environment: str, dateFinished: str(date-time), name: str?}, status: str, url: str?, userAgent: str?, version: str?, versionInfo: map?{description: str, package: str?, version: map{major: int, minor: int, patch: int, pre: str?, buildCode: str?, components: int, raw: str}, buildHash: str?}}, userReport: map?{id: str, eventID: str, name: str?, email: str?, comments: str, dateCreated: str(date-time), user: map?{id: str, username: str?, email: str?, name: str?, ipAddress: str?, avatarUrl: str?}, event: map{id: str, eventID: str}}, sdkUpdates: [any], resolvedWith: [str], nextEventID: str?, previousEventID: str?}
@errors {401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/events/{event_id}/attachments/
@required {project_id_or_slug: str, event_id: str}
@optional {query: str, cursor: str}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/events/{event_id}/attachments/{attachment_id}/
@required {project_id_or_slug: str, event_id: str, attachment_id: str}
@optional {download: str}
@returns(200) {id: str, event_id: str, type: str, name: str, mimetype: str?, dateCreated: str(date-time), size: int, headers: map, sha1: str?}
@errors {401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/events/{event_id}/source-map-debug/
@required {project_id_or_slug: str, event_id: str}
@returns(200) {dist: str?, release: str?, exceptions: [map], has_debug_ids: bool, min_debug_id_sdk_version: str?, sdk_version: str?, project_has_some_artifact_bundle: bool, release_has_some_artifact: bool, has_uploaded_some_artifact_with_a_debug_id: bool, sdk_debug_id_support: str, has_scraping_data: bool}
@errors {401, 403, 404}

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/files/difs/assemble/
@required {project_id_or_slug: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/files/dsyms/
@required {project_id_or_slug: str}
@optional {query: str, debug_id: str, code_id: str, file_formats: [str], cursor: str}
@returns(200)
@errors {401, 403, 404}

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/files/preprodartifacts/assemble/
@required {project_id_or_slug: str, checksum: str, chunks: [str]}
@optional {build_configuration: str, release_notes: str, install_groups: [str], head_sha: str, base_sha: str, provider: str, head_repo_name: str, base_repo_name: str, head_ref: str, base_ref: str, pr_number: int}
@returns(200) {state: str, missingChunks: [str], artifactUrl: str(uri)}
@errors {400, 401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/filters/
@required {project_id_or_slug: str}
@returns(200)
@errors {403}

@endpoint PUT /projects/{organization_id_or_slug}/{project_id_or_slug}/filters/{filter_id}/
@required {project_id_or_slug: str, filter_id: str}
@optional {active: bool, subfilters: [str]}
@returns(204)
@errors {400, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/keys/
@required {project_id_or_slug: str}
@optional {cursor: str, status: str}
@returns(200)
@errors {400, 403}

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/keys/
@required {project_id_or_slug: str}
@optional {name: str, rateLimit: map{count: int, window: int}, useCase: str(user/profiling/tempest/demo)=user}
@returns(201) {id: str, name: str, label: str, public: str?, secret: str?, projectId: int, isActive: bool, rateLimit: map?{window: int, count: int}, dsn: map{secret: str(uri), public: str(uri), csp: str(uri), security: str(uri), minidump: str(uri), nel: str(uri), unreal: str(uri), crons: str(uri), cdn: str(uri), playstation: str(uri), integration: str(uri), otlp_traces: str(uri), otlp_logs: str(uri)}, browserSdkVersion: str, browserSdk: map{choices: [[str]]}, dateCreated: str(date-time)?, dynamicSdkLoaderOptions: map{hasReplay: bool, hasPerformance: bool, hasDebug: bool, hasFeedback: bool, hasLogsAndMetrics: bool}, useCase: str}
@errors {400, 403}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/keys/{key_id}/
@required {project_id_or_slug: str, key_id: str}
@returns(200) {id: str, name: str, label: str, public: str?, secret: str?, projectId: int, isActive: bool, rateLimit: map?{window: int, count: int}, dsn: map{secret: str(uri), public: str(uri), csp: str(uri), security: str(uri), minidump: str(uri), nel: str(uri), unreal: str(uri), crons: str(uri), cdn: str(uri), playstation: str(uri), integration: str(uri), otlp_traces: str(uri), otlp_logs: str(uri)}, browserSdkVersion: str, browserSdk: map{choices: [[str]]}, dateCreated: str(date-time)?, dynamicSdkLoaderOptions: map{hasReplay: bool, hasPerformance: bool, hasDebug: bool, hasFeedback: bool, hasLogsAndMetrics: bool}, useCase: str}
@errors {403, 404}

@endpoint PUT /projects/{organization_id_or_slug}/{project_id_or_slug}/keys/{key_id}/
@required {project_id_or_slug: str, key_id: str}
@optional {name: str, isActive: bool, rateLimit: map{count: int, window: int}, browserSdkVersion: str(latest/7.x), dynamicSdkLoaderOptions: map{hasReplay: bool, hasPerformance: bool, hasDebug: bool, hasFeedback: bool, hasLogsAndMetrics: bool}}
@returns(200) {id: str, name: str, label: str, public: str?, secret: str?, projectId: int, isActive: bool, rateLimit: map?{window: int, count: int}, dsn: map{secret: str(uri), public: str(uri), csp: str(uri), security: str(uri), minidump: str(uri), nel: str(uri), unreal: str(uri), crons: str(uri), cdn: str(uri), playstation: str(uri), integration: str(uri), otlp_traces: str(uri), otlp_logs: str(uri)}, browserSdkVersion: str, browserSdk: map{choices: [[str]]}, dateCreated: str(date-time)?, dynamicSdkLoaderOptions: map{hasReplay: bool, hasPerformance: bool, hasDebug: bool, hasFeedback: bool, hasLogsAndMetrics: bool}, useCase: str}
@errors {400, 403, 404}

@endpoint DELETE /projects/{organization_id_or_slug}/{project_id_or_slug}/keys/{key_id}/
@required {project_id_or_slug: str, key_id: str}
@returns(204)
@errors {403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/members/
@required {project_id_or_slug: str}
@returns(200)
@errors {400, 403}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/monitors/{monitor_id_or_slug}/
@required {project_id_or_slug: str, monitor_id_or_slug: str}
@returns(200) {id: str, name: str, slug: str, status: str, isMuted: bool, isUpserting: bool, config: map{schedule_type: str, schedule: any, checkin_margin: int?, max_runtime: int?, timezone: str?, failure_issue_threshold: int?, recovery_threshold: int?, alert_rule_id: int?}, dateCreated: str(date-time), project: map{stats: any, transactionStats: [[int]], sessionStats: map{currentCrashFreeRate: num(double)?, previousCrashFreeRate: num(double)?, hasHealthData: bool}, id: str, slug: str, name: str, platform: str?, dateCreated: str(date-time), isBookmarked: bool, isMember: bool, features: [str], firstEvent: str(date-time)?, firstTransactionEvent: bool, access: [str], hasAccess: bool, hasFeedbacks: bool, hasFlags: bool, hasMinifiedStackTrace: bool, hasMonitors: bool, hasNewFeedbacks: bool, hasProfiles: bool, hasReplays: bool, hasSessions: bool, hasInsightsHttp: bool, hasInsightsDb: bool, hasInsightsAssets: bool, hasInsightsAppStart: bool, hasInsightsScreenLoad: bool, hasInsightsVitals: bool, hasInsightsCaches: bool, hasInsightsQueues: bool, hasInsightsAgentMonitoring: bool, hasInsightsMCP: bool, hasLogs: bool, hasTraceMetrics: bool, isInternal: bool, isPublic: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, color: str, status: str}, environments: [map], owner: map?{type: str, id: str, name: str, email: str}}
@errors {401, 403, 404}

@endpoint PUT /projects/{organization_id_or_slug}/{project_id_or_slug}/monitors/{monitor_id_or_slug}/
@required {project_id_or_slug: str, monitor_id_or_slug: str, project: str, name: str, config: any}
@optional {slug: str, status: str(active/disabled)=active, owner: str, is_muted: bool}
@returns(200) {id: str, name: str, slug: str, status: str, isMuted: bool, isUpserting: bool, config: map{schedule_type: str, schedule: any, checkin_margin: int?, max_runtime: int?, timezone: str?, failure_issue_threshold: int?, recovery_threshold: int?, alert_rule_id: int?}, dateCreated: str(date-time), project: map{stats: any, transactionStats: [[int]], sessionStats: map{currentCrashFreeRate: num(double)?, previousCrashFreeRate: num(double)?, hasHealthData: bool}, id: str, slug: str, name: str, platform: str?, dateCreated: str(date-time), isBookmarked: bool, isMember: bool, features: [str], firstEvent: str(date-time)?, firstTransactionEvent: bool, access: [str], hasAccess: bool, hasFeedbacks: bool, hasFlags: bool, hasMinifiedStackTrace: bool, hasMonitors: bool, hasNewFeedbacks: bool, hasProfiles: bool, hasReplays: bool, hasSessions: bool, hasInsightsHttp: bool, hasInsightsDb: bool, hasInsightsAssets: bool, hasInsightsAppStart: bool, hasInsightsScreenLoad: bool, hasInsightsVitals: bool, hasInsightsCaches: bool, hasInsightsQueues: bool, hasInsightsAgentMonitoring: bool, hasInsightsMCP: bool, hasLogs: bool, hasTraceMetrics: bool, isInternal: bool, isPublic: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, color: str, status: str}, environments: [map], owner: map?{type: str, id: str, name: str, email: str}}
@errors {400, 401, 403, 404}

@endpoint DELETE /projects/{organization_id_or_slug}/{project_id_or_slug}/monitors/{monitor_id_or_slug}/
@required {project_id_or_slug: str, monitor_id_or_slug: str}
@optional {environment: [str]}
@returns(202)
@errors {401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/monitors/{monitor_id_or_slug}/checkins/
@required {project_id_or_slug: str, monitor_id_or_slug: str}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/ownership/
@required {project_id_or_slug: str}
@returns(200) {schema: map?{$version: int, rules: [map]}, raw: str?, fallthrough: bool, dateCreated: str(date-time)?, lastUpdated: str(date-time)?, isActive: bool, autoAssignment: str, codeownersAutoSync: bool?}

@endpoint PUT /projects/{organization_id_or_slug}/{project_id_or_slug}/ownership/
@required {project_id_or_slug: str}
@optional {raw: str, fallthrough: bool, autoAssignment: str, codeownersAutoSync: bool=true}
@returns(200) {schema: map?{$version: int, rules: [map]}, raw: str?, fallthrough: bool, dateCreated: str(date-time)?, lastUpdated: str(date-time)?, isActive: bool, autoAssignment: str, codeownersAutoSync: bool?}
@errors {400}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/preprod/size-analysis/status-check-rules/
@required {project_id_or_slug: str}
@returns(200) {enabled: bool, rules: [map]}
@errors {403, 404}

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/preprod/size-analysis/status-checks/skip/
@required {project_id_or_slug: str, sha: str, repository: str, provider: str(github/github_enterprise)}
@returns(200)
@errors {400, 403, 404, 429, 502}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/preprod/snapshots/status-check-rules/
@required {project_id_or_slug: str}
@returns(200) {enabled: bool, rules: map{failOnAdded: bool, failOnRemoved: bool, failOnChanged: bool, failOnRenamed: bool}}
@errors {403, 404}

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/preprod/snapshots/status-checks/skip/
@required {project_id_or_slug: str, sha: str, repository: str, provider: str(github/github_enterprise)}
@returns(200)
@errors {400, 403, 404, 429, 502}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/preprodartifacts/build-distribution/latest/
@required {project_id_or_slug: str, appId: str, platform: str(apple/android)}
@optional {buildVersion: str, buildNumber: any, mainBinaryIdentifier: str, buildConfiguration: str, codesigningType: str, installGroups: [str]}
@returns(200) {latestArtifact: map?{buildId: str, state: str, appInfo: map{appId: str?, name: str?, version: str?, buildNumber: int?, artifactType: str?, dateAdded: str(date-time)?, dateBuilt: str(date-time)?}, gitInfo: map?{headSha: str?, baseSha: str?, provider: str?, headRepoName: str?, baseRepoName: str?, headRef: str?, baseRef: str?, prNumber: int?}, platform: str?, projectId: str, projectSlug: str, buildConfiguration: str?, isInstallable: bool, installUrl: str(uri)?, installUrlExpiresAt: str(date-time)?, downloadCount: int, releaseNotes: str?, installGroups: [str]?, isCodeSignatureValid: bool?, profileName: str?, codesigningType: str?}, currentArtifact: map?{buildId: str, state: str, appInfo: map{appId: str?, name: str?, version: str?, buildNumber: int?, artifactType: str?, dateAdded: str(date-time)?, dateBuilt: str(date-time)?}, gitInfo: map?{headSha: str?, baseSha: str?, provider: str?, headRepoName: str?, baseRepoName: str?, headRef: str?, baseRef: str?, prNumber: int?}, platform: str?, projectId: str, projectSlug: str, buildConfiguration: str?, isInstallable: bool, installUrl: str(uri)?, installUrlExpiresAt: str(date-time)?, downloadCount: int, releaseNotes: str?, installGroups: [str]?, isCodeSignatureValid: bool?, profileName: str?, codesigningType: str?}}
@errors {400, 403}

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/preprodartifacts/snapshots/
@required {project_id_or_slug: str, app_id: str, images: map}
@optional {diff_threshold: num, selective: bool, all_image_file_names: [str], head_sha: str, base_sha: str, provider: str, head_repo_name: str, base_repo_name: str, head_ref: str, base_ref: str, pr_number: int}
@returns(200) {artifactId: str, snapshotMetricsId: str, imageCount: int, snapshotUrl: str(uri)}
@errors {400, 403}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/profiling/profiles/{profile_id}/
@required {project_id_or_slug: str, profile_id: str}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/releases/
@required {project_id_or_slug: str}
@optional {environment: [str], query: str, per_page: int, cursor: str}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/releases/{version}/commits/
@required {project_id_or_slug: str, version: str}
@optional {cursor: str}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/releases/{version}/files/
@required {project_id_or_slug: str, version: str}
@optional {query: [str], checksum: [str], cursor: str}
@returns(200)
@errors {401, 403, 404}

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/releases/{version}/files/
@required {project_id_or_slug: str, version: str}
@returns(201) {id: any, name: str, dist: str?, headers: map, size: int?, sha1: str?, dateCreated: str(date-time)}
@errors {400, 401, 403, 404, 409}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/releases/{version}/files/{file_id}/
@required {project_id_or_slug: str, version: str, file_id: str}
@optional {download: str}
@returns(200) {id: any, name: str, dist: str?, headers: map, size: int?, sha1: str?, dateCreated: str(date-time)}
@errors {401, 403, 404}

@endpoint PUT /projects/{organization_id_or_slug}/{project_id_or_slug}/releases/{version}/files/{file_id}/
@required {project_id_or_slug: str, version: str, file_id: str, name: str}
@returns(200) {id: any, name: str, dist: str?, headers: map, size: int?, sha1: str?, dateCreated: str(date-time)}
@errors {400, 401, 403, 404}

@endpoint DELETE /projects/{organization_id_or_slug}/{project_id_or_slug}/releases/{version}/files/{file_id}/
@required {project_id_or_slug: str, version: str, file_id: str}
@returns(204)
@errors {401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/releases/completion/
@required {project_id_or_slug: str}
@returns(200)
@errors {401, 403, 404}

@endpoint DELETE /projects/{organization_id_or_slug}/{project_id_or_slug}/replays/{replay_id}/
@required {project_id_or_slug: str, replay_id: str}
@returns(204)
@errors {404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/replays/{replay_id}/clicks/
@required {project_id_or_slug: str, replay_id: str}
@optional {cursor: str, environment: [str], per_page: int, query: str}
@returns(200) {data: [map]}
@errors {400, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/replays/{replay_id}/recording-segments/
@required {project_id_or_slug: str, replay_id: str}
@optional {cursor: str, per_page: int}
@returns(200)
@errors {400, 403, 404, 429}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/replays/{replay_id}/recording-segments/{segment_id}/
@required {project_id_or_slug: str, replay_id: str, segment_id: int}
@returns(200) {data: map{replayId: str, segmentId: int, projectId: str, dateAdded: str?}}
@errors {400, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/replays/{replay_id}/viewed-by/
@required {project_id_or_slug: str, replay_id: str}
@returns(200) {data: map{viewed_by: [map]}}
@errors {400, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/replays/jobs/delete/
@required {project_id_or_slug: str}
@returns(200) {data: [map]}
@errors {403}

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/replays/jobs/delete/
@required {project_id_or_slug: str, data: map{rangeStart!: str(date-time), rangeEnd!: str(date-time), environments!: [str], query!: str}}
@returns(201) {data: map{id: int, dateCreated: str(date-time), dateUpdated: str(date-time), rangeStart: str(date-time), rangeEnd: str(date-time), environments: [str], status: str, query: str, countDeleted: int}}
@errors {400, 403}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/replays/jobs/delete/{job_id}/
@required {project_id_or_slug: str, job_id: int}
@returns(200) {data: map{id: int, dateCreated: str(date-time), dateUpdated: str(date-time), rangeStart: str(date-time), rangeEnd: str(date-time), environments: [str], status: str, query: str, countDeleted: int}}
@errors {403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/repo/
@required {project_id_or_slug: str}
@optional {includeMappingCount: str}
@returns(200)

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/repo/
@required {project_id_or_slug: str, repositoryId: int}
@returns(201) {id: str, projectId: str, repositoryId: str, source: str, created: bool}
@errors {400, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/seer/repos/
@required {project_id_or_slug: str}
@optional {query: str, sortBy: str(-name/-provider/name/provider), cursor: str, per_page: int}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/seer/repos/
@required {project_id_or_slug: str, repos: [map{repository_id!: int, branch_name: str, instructions: str, branch_overrides: [map]}]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint PUT /projects/{organization_id_or_slug}/{project_id_or_slug}/seer/repos/
@required {project_id_or_slug: str, repos: [map{repository_id!: int, branch_name: str, instructions: str, branch_overrides: [map]}]}
@returns(204)
@errors {400, 401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/stacktrace-link/
@required {project_id_or_slug: str, file: str}
@optional {platform: str, absPath: str, commitId: str, sdkName: str, module: str, package: str, lineNo: str, groupId: str}
@returns(200) {sourcePath: str?, attemptedUrl: str?, error: str?, config: map?{id: str, projectId: str, projectSlug: str, repoId: str, repoName: str, integrationId: str?, provider: map?{key: str, slug: str, name: str, canAdd: bool, canDisable: bool, features: [str], aspects: map{alerts: [map], configure_integration: map, directEnable: bool, disable_dialog: map, externalInstall: map, removal_dialog: map}}, stackRoot: str, sourceRoot: str, defaultBranch: str?, automaticallyGenerated: bool, hasCodeOwner: bool}, sourceUrl: str?, integrations: [map]}
@errors {400, 401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/stats/
@required {project_id_or_slug: str}
@optional {stat: str(blacklisted/generated/received/rejected), since: num(double), until: num(double), resolution: str(10s/1d/1h)}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/symbol-sources/
@required {project_id_or_slug: str}
@optional {id: str}
@returns(200)
@errors {403, 404}

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/symbol-sources/
@required {project_id_or_slug: str, type: str(http/gcs/s3/azure), name: str}
@optional {id: str, layout: map{type!: str, casing!: str}, filters: map{filetypes: [str], path_patterns: [str], requires_checksum: bool}, url: str, username: str, password: str, bucket: str, region: str(us-east-2/us-east-1/us-west-1/us-west-2/ap-east-1/ap-south-1/ap-northeast-2/ap-southeast-1/ap-southeast-2/ap-northeast-1/ca-central-1/cn-north-1/cn-northwest-1/eu-central-1/eu-west-1/eu-west-2/eu-west-3/eu-north-1/sa-east-1/us-gov-east-1/us-gov-west-1), access_key: str, secret_key: str, prefix: str, client_email: str, private_key: str, account: str, container: str, tenant_id: str, client_id: str, client_secret: str}
@returns(201)
@errors {400, 403}

@endpoint PUT /projects/{organization_id_or_slug}/{project_id_or_slug}/symbol-sources/
@required {project_id_or_slug: str, id: str, type: str(http/gcs/s3/azure), name: str}
@optional {id: str, layout: map{type!: str, casing!: str}, filters: map{filetypes: [str], path_patterns: [str], requires_checksum: bool}, url: str, username: str, password: str, bucket: str, region: str(us-east-2/us-east-1/us-west-1/us-west-2/ap-east-1/ap-south-1/ap-northeast-2/ap-southeast-1/ap-southeast-2/ap-northeast-1/ca-central-1/cn-north-1/cn-northwest-1/eu-central-1/eu-west-1/eu-west-2/eu-west-3/eu-north-1/sa-east-1/us-gov-east-1/us-gov-west-1), access_key: str, secret_key: str, prefix: str, client_email: str, private_key: str, account: str, container: str, tenant_id: str, client_id: str, client_secret: str}
@returns(200)
@errors {400, 403, 404}

@endpoint DELETE /projects/{organization_id_or_slug}/{project_id_or_slug}/symbol-sources/
@required {project_id_or_slug: str, id: str}
@returns(204)
@errors {403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/teams/
@required {project_id_or_slug: str}
@optional {cursor: str}
@returns(200)
@errors {403, 404}

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/teams/{team_id_or_slug}/
@required {project_id_or_slug: str, team_id_or_slug: str}
@returns(201) {stats: any, transactionStats: [[int]], sessionStats: map{currentCrashFreeRate: num(double)?, previousCrashFreeRate: num(double)?, hasHealthData: bool}, id: str, slug: str, name: str, platform: str?, dateCreated: str(date-time), isBookmarked: bool, isMember: bool, features: [str], firstEvent: str(date-time)?, firstTransactionEvent: bool, access: [str], hasAccess: bool, hasFeedbacks: bool, hasFlags: bool, hasMinifiedStackTrace: bool, hasMonitors: bool, hasNewFeedbacks: bool, hasProfiles: bool, hasReplays: bool, hasSessions: bool, hasInsightsHttp: bool, hasInsightsDb: bool, hasInsightsAssets: bool, hasInsightsAppStart: bool, hasInsightsScreenLoad: bool, hasInsightsVitals: bool, hasInsightsCaches: bool, hasInsightsQueues: bool, hasInsightsAgentMonitoring: bool, hasInsightsMCP: bool, hasLogs: bool, hasTraceMetrics: bool, isInternal: bool, isPublic: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, color: str, status: str, team: map{id: str, name: str, slug: str}, teams: [map]}
@errors {403, 404}

@endpoint DELETE /projects/{organization_id_or_slug}/{project_id_or_slug}/teams/{team_id_or_slug}/
@required {project_id_or_slug: str, team_id_or_slug: str}
@returns(200) {stats: any, transactionStats: [[int]], sessionStats: map{currentCrashFreeRate: num(double)?, previousCrashFreeRate: num(double)?, hasHealthData: bool}, id: str, slug: str, name: str, platform: str?, dateCreated: str(date-time), isBookmarked: bool, isMember: bool, features: [str], firstEvent: str(date-time)?, firstTransactionEvent: bool, access: [str], hasAccess: bool, hasFeedbacks: bool, hasFlags: bool, hasMinifiedStackTrace: bool, hasMonitors: bool, hasNewFeedbacks: bool, hasProfiles: bool, hasReplays: bool, hasSessions: bool, hasInsightsHttp: bool, hasInsightsDb: bool, hasInsightsAssets: bool, hasInsightsAppStart: bool, hasInsightsScreenLoad: bool, hasInsightsVitals: bool, hasInsightsCaches: bool, hasInsightsQueues: bool, hasInsightsAgentMonitoring: bool, hasInsightsMCP: bool, hasLogs: bool, hasTraceMetrics: bool, isInternal: bool, isPublic: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, color: str, status: str, team: map{id: str, name: str, slug: str}, teams: [map]}
@errors {403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/trace-items/{item_id}/
@required {project_id_or_slug: str, item_id: str, trace_id: str, item_type: str(attachments/logs/occurrences/preprod/processing_errors/profile_functions/spans/tracemetrics/uptime_results)}
@optional {routing_hint: str, timestamp: str(date-time), statsPeriod: str, start: str(date-time), end: str(date-time)}
@returns(200) {itemId: str, timestamp: str, attributes: [map], meta: map, links: [map]?, event: map{contexts: any, extra: any, breadcrumbs: any}}
@errors {400, 401, 403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/user-feedback/
@required {project_id_or_slug: str}
@optional {cursor: str}
@returns(200)
@errors {403, 404}

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/user-feedback/
@required {project_id_or_slug: str, name: str, email: str(email), comments: str, event_id: str}
@returns(200) {id: str, eventID: str, name: str?, email: str?, comments: str, dateCreated: str(date-time), user: map?{id: str, username: str?, email: str?, name: str?, ipAddress: str?, avatarUrl: str?}, event: map{id: str, eventID: str}, issue: map?{isUnhandled: bool, count: str, userCount: int, firstSeen: str(date-time)?, lastSeen: str(date-time)?, derivedData: map{blocker: str, progress: str, status: str, viewCount: int, hasOpenFixPr: bool, isAssigned: bool, hasRootCause: bool, lastCompletedAutofixStep: str, lastProgressedAt: str(date-time)?, impact: map?{score: num(double)?, level: str?, description: str, citations: [map], sourceEventId: str}}, id: str, shareId: str?, shortId: str?, title: str, culprit: str?, permalink: str(uri), logger: str?, level: str, status: str, statusDetails: map{ignoreCount: int?, ignoreUntil: str(date-time)?, ignoreUserCount: int?, ignoreUserWindow: int?, ignoreWindow: int?, actor: map?{identities: [map], avatar: map, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, inNextRelease: bool, inRelease: str, inCommit: str, pendingEvents: int, info: map?{dateCreated: str, syncCount: int, totalEvents: int}}, substatus: str?, isPublic: bool, platform: str?, priority: str?, priorityLockedAt: str(date-time)?, seerFixabilityScore: num(double)?, seerAutofixLastTriggered: str(date-time)?, seerExplorerAutofixLastTriggered: str(date-time)?, project: map{id: str, name: str, slug: str, platform: str?}, type: str, issueType: str, issueCategory: str, metadata: map{title: str, value: str, type: str, synthetic: bool, filename: str, function: str, message: str, uri: str, directive: str, origin: str, name: str, contact_email: str, source: str, in_app_frame_mix: str, stripped_crash: bool, sdk: map{name: str, name_normalized: str}, severity: num(double), severity_reason: str, initial_priority: int}, numComments: int, assignedTo: map?{type: str, id: str, name: str, email: str}, isBookmarked: bool, isSubscribed: bool, subscriptionDetails: map?{disabled: bool, reason: str}, hasSeen: bool, annotations: [map]}}
@errors {400, 403, 404, 409}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/users/
@required {project_id_or_slug: str}
@optional {query: str, cursor: str}
@returns(200)
@errors {401, 403, 404}

@endgroup

@group seer
@endpoint GET /seer/models/
@returns(200) {models: [str]}

@endgroup

@group sentry-app-installations
@endpoint POST /sentry-app-installations/{uuid}/external-issue-actions/
@required {uuid: str, groupId: str, action: str(link/create), uri: str}
@optional {expectedExternalIssueUrl: str(uri)}
@returns(200) {id: str, issueId: str, serviceType: str, displayName: str, webUrl: str}
@returns(201) {id: str, issueId: str, serviceType: str, displayName: str, webUrl: str}
@errors {400, 401, 403, 404, 409}

@endpoint GET /sentry-app-installations/{uuid}/external-requests/
@required {uuid: str, uri: str}
@optional {projectId: int, query: str, dependentData: str}
@returns(200) {choices: [[str]], defaultValue: str}
@errors {400, 401, 403, 404}

@endgroup

@group sentry-apps
@endpoint GET /sentry-apps/{sentry_app_id_or_slug}/
@required {sentry_app_id_or_slug: str}
@returns(200) {allowedOrigins: [str], avatars: [map], events: [str], webhookEvents: [str], featureData: [str], isAlertable: bool, metadata: str, name: str, schema: str, scopes: [str], slug: str, status: str, uuid: str(uuid), verifyInstall: bool, webhookHeaders: [str], isDisabled: bool, author: str?, overview: str?, popularity: int?, redirectUrl: str?, webhookUrl: str?, clientSecret: str?, datePublished: str(date-time), clientId: str, owner: map{id: int, slug: str}}

@endpoint PUT /sentry-apps/{sentry_app_id_or_slug}/
@required {sentry_app_id_or_slug: str, name: str, scopes: [str]}
@optional {author: str, events: [str], features: [int], schema: map, webhookUrl: str(uri), redirectUrl: str(uri), isInternal: bool=false, isAlertable: bool=false, overview: str, verifyInstall: bool=true, allowedOrigins: [str], webhookHeaders: [str]}
@returns(200) {allowedOrigins: [str], avatars: [map], events: [str], webhookEvents: [str], featureData: [str], isAlertable: bool, metadata: str, name: str, schema: str, scopes: [str], slug: str, status: str, uuid: str(uuid), verifyInstall: bool, webhookHeaders: [str], isDisabled: bool, author: str?, overview: str?, popularity: int?, redirectUrl: str?, webhookUrl: str?, clientSecret: str?, datePublished: str(date-time), clientId: str, owner: map{id: int, slug: str}}
@errors {400, 403}

@endpoint DELETE /sentry-apps/{sentry_app_id_or_slug}/
@required {sentry_app_id_or_slug: str}
@returns(204)
@errors {403}

@endgroup

@group teams
@endpoint GET /teams/{organization_id_or_slug}/{team_id_or_slug}/
@required {team_id_or_slug: str}
@optional {expand: str, collapse: str}
@returns(200) {id: str, slug: str, name: str, dateCreated: str(date-time)?, isMember: bool, teamRole: str?, flags: map, access: [str], hasAccess: bool, isPending: bool, memberCount: int, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, externalTeams: [map], organization: map{features: [str], extraOptions: map, access: [str], onboardingTasks: [map], id: str, slug: str, status: map{id: str, name: str}, name: str, dateCreated: str(date-time), isEarlyAdopter: bool, require2FA: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, links: map{organizationUrl: str, regionUrl: str}, hasAuthProvider: bool, allowMemberInvite: bool, allowMemberProjectCreation: bool, allowSuperuserAccess: bool}, projects: [map]}
@errors {401, 403, 404}

@endpoint PUT /teams/{organization_id_or_slug}/{team_id_or_slug}/
@required {team_id_or_slug: str, slug: str}
@optional {name: str}
@returns(200) {id: str, slug: str, name: str, dateCreated: str(date-time)?, isMember: bool, teamRole: str?, flags: map, access: [str], hasAccess: bool, isPending: bool, memberCount: int, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, externalTeams: [map], organization: map{features: [str], extraOptions: map, access: [str], onboardingTasks: [map], id: str, slug: str, status: map{id: str, name: str}, name: str, dateCreated: str(date-time), isEarlyAdopter: bool, require2FA: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, links: map{organizationUrl: str, regionUrl: str}, hasAuthProvider: bool, allowMemberInvite: bool, allowMemberProjectCreation: bool, allowSuperuserAccess: bool}, projects: [map]}
@errors {400, 401, 403, 404}

@endpoint DELETE /teams/{organization_id_or_slug}/{team_id_or_slug}/
@required {team_id_or_slug: str}
@returns(204)
@errors {403, 404}

@endpoint POST /teams/{organization_id_or_slug}/{team_id_or_slug}/external-teams/
@required {team_id_or_slug: str, team_id: int, external_name: str, provider: str(github/github_enterprise/jira_server/slack/slack_staging/perforce/gitlab/cursor_origin/msteams/custom_scm), integration_id: int}
@optional {external_id: str}
@returns(200) {externalId: str, userId: str, teamId: str, id: str, provider: str, externalName: str, integrationId: str}
@returns(201) {externalId: str, userId: str, teamId: str, id: str, provider: str, externalName: str, integrationId: str}
@errors {400, 403}

@endpoint PUT /teams/{organization_id_or_slug}/{team_id_or_slug}/external-teams/{external_team_id}/
@required {team_id_or_slug: str, external_team_id: int, team_id: int, external_name: str, provider: str(github/github_enterprise/jira_server/slack/slack_staging/perforce/gitlab/cursor_origin/msteams/custom_scm), integration_id: int}
@optional {external_id: str}
@returns(200) {externalId: str, userId: str, teamId: str, id: str, provider: str, externalName: str, integrationId: str}
@errors {400, 403}

@endpoint DELETE /teams/{organization_id_or_slug}/{team_id_or_slug}/external-teams/{external_team_id}/
@required {team_id_or_slug: str, external_team_id: int}
@returns(204)
@errors {400, 403}

@endpoint GET /teams/{organization_id_or_slug}/{team_id_or_slug}/members/
@required {team_id_or_slug: str}
@optional {cursor: str}
@returns(200)
@errors {403, 404}

@endpoint GET /teams/{organization_id_or_slug}/{team_id_or_slug}/projects/
@required {team_id_or_slug: str}
@optional {cursor: str}
@returns(200)
@errors {400, 403, 404}

@endpoint POST /teams/{organization_id_or_slug}/{team_id_or_slug}/projects/
@required {team_id_or_slug: str, name: str}
@optional {slug: str, platform: str, default_rules: bool}
@returns(201) {latestDeploys: map?, options: map, stats: any, transactionStats: [[int]], sessionStats: map{currentCrashFreeRate: num(double)?, previousCrashFreeRate: num(double)?, hasHealthData: bool}, id: str, slug: str, name: str, platform: str?, dateCreated: str(date-time), isBookmarked: bool, isMember: bool, features: [str], firstEvent: str(date-time)?, firstTransactionEvent: bool, access: [str], hasAccess: bool, hasFeedbacks: bool, hasFlags: bool, hasMinifiedStackTrace: bool, hasMonitors: bool, hasNewFeedbacks: bool, hasProfiles: bool, hasReplays: bool, hasSessions: bool, hasInsightsHttp: bool, hasInsightsDb: bool, hasInsightsAssets: bool, hasInsightsAppStart: bool, hasInsightsScreenLoad: bool, hasInsightsVitals: bool, hasInsightsCaches: bool, hasInsightsQueues: bool, hasInsightsAgentMonitoring: bool, hasInsightsMCP: bool, hasLogs: bool, hasTraceMetrics: bool, team: map?{id: str, name: str, slug: str}, teams: [map], platforms: [str], hasUserReports: bool, environments: [str], latestRelease: map?{version: str}}
@errors {400, 403, 404, 409}

@endgroup

@group users
@endpoint GET /users/{user_id}/
@required {user_id: str}
@returns(200) {identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map], permissions: [str], options: map{theme: str, language: str, stacktraceOrder: int, defaultIssueEvent: str, timezone: str, clock24Hours: bool, prefersIssueDetailsStreamlinedUI: bool?}, flags: map{newsletter_consent_prompt: bool}}
@errors {401, 403, 404}

@endgroup

@group projects
@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/tags/{key}/values/
@required {project_id_or_slug: str, key: str}
@optional {cursor: str}
@returns(200)
@errors {403}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/hooks/
@required {project_id_or_slug: str}
@optional {cursor: str}
@returns(200)
@errors {403}

@endpoint POST /projects/{organization_id_or_slug}/{project_id_or_slug}/hooks/
@required {project_id_or_slug: str, url: str, events: [str]}
@returns(201) {dateCreated: str, events: [str], id: str, secret: str, status: str, url: str}
@errors {403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/hooks/{hook_id}/
@required {project_id_or_slug: str, hook_id: str}
@returns(200) {dateCreated: str, events: [str], id: str, secret: str, status: str, url: str}
@errors {403, 404}

@endpoint PUT /projects/{organization_id_or_slug}/{project_id_or_slug}/hooks/{hook_id}/
@required {project_id_or_slug: str, hook_id: str, url: str, events: [str]}
@returns(200) {dateCreated: str, events: [str], id: str, secret: str, status: str, url: str}
@errors {400, 403, 404}

@endpoint DELETE /projects/{organization_id_or_slug}/{project_id_or_slug}/hooks/{hook_id}/
@required {project_id_or_slug: str, hook_id: str}
@returns(204)
@errors {403, 404}

@endpoint GET /projects/{organization_id_or_slug}/{project_id_or_slug}/issues/
@required {project_id_or_slug: str}
@optional {statsPeriod: str, shortIdLookup: str(1/0), query: str, hashes: str, sort: str(date/new/trends/freq/user/recommended)=date, limit: int=100, cursor: str}
@returns(200)
@errors {403}

@endpoint PUT /projects/{organization_id_or_slug}/{project_id_or_slug}/issues/
@required {project_id_or_slug: str}
@optional {id: int, query: str, status: str, statusDetails: map{inRelease: str, inNextRelease: bool, inCommit: str, ignoreDuration: int, ignoreCount: int, ignoreWindow: int, ignoreUserCount: int, ignoreUserWindow: int}, ignoreDuration: int, isPublic: bool, merge: bool, assignedTo: str, hasSeen: bool, isBookmarked: bool}
@returns(200) {isPublic: bool, status: str, statusDetails: map{ignoreCount: int?, ignoreUntil: str(date-time)?, ignoreUserCount: int?, ignoreUserWindow: int?, ignoreWindow: int?, ignoreUntilEscalating: bool, actor: map?{id: str, name: str, username: str, email: str}, inNextRelease: bool, inRelease: str, inCommit: map{id: str, message: str?, dateCreated: str(date-time)}}}
@errors {400, 403, 404}

@endpoint DELETE /projects/{organization_id_or_slug}/{project_id_or_slug}/issues/
@required {project_id_or_slug: str}
@optional {id: int, query: str}
@returns(204)
@errors {403, 404}

@endgroup

@group organizations
@endpoint GET /organizations/{organization_id_or_slug}/releases/{version}/commitfiles/
@required {version: str}
@returns(200)
@errors {403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/sentry-app-installations/
@optional {cursor: str}
@returns(200)
@errors {403, 404}

@endgroup

@group sentry-app-installations
@endpoint POST /sentry-app-installations/{uuid}/external-issues/
@required {uuid: str, issueId: int, webUrl: str, project: str, identifier: str}
@returns(200) {id: str, issueId: str, serviceType: str, displayName: str, webUrl: str}
@errors {403, 404}

@endpoint DELETE /sentry-app-installations/{uuid}/external-issues/{external_issue_id}/
@required {uuid: str, external_issue_id: str}
@returns(204)
@errors {403, 404, 409}

@endgroup

@group organizations
@endpoint POST /organizations/{organization_id_or_slug}/spike-protections/
@required {projects: [str]}
@returns(201)
@errors {400, 403}

@endpoint DELETE /organizations/{organization_id_or_slug}/spike-protections/
@required {projects: [str]}
@returns(200)
@errors {400, 403}

@endpoint GET /organizations/{organization_id_or_slug}/issues/{issue_id}/
@required {issue_id: str}
@optional {environment: [str], expand: [str], collapse: [str]}
@returns(200) {isUnhandled: bool, count: str, userCount: int, firstSeen: str(date-time)?, lastSeen: str(date-time)?, derivedData: map{blocker: str, progress: str, status: str, viewCount: int, hasOpenFixPr: bool, isAssigned: bool, hasRootCause: bool, lastCompletedAutofixStep: str, lastProgressedAt: str(date-time)?, impact: map?{score: num(double)?, level: str?, description: str, citations: [map], sourceEventId: str}}, id: str, shareId: str?, shortId: str?, title: str, culprit: str?, permalink: str(uri), logger: str?, level: str, status: str, statusDetails: map{ignoreCount: int?, ignoreUntil: str(date-time)?, ignoreUserCount: int?, ignoreUserWindow: int?, ignoreWindow: int?, actor: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, inNextRelease: bool, inRelease: str, inCommit: str, pendingEvents: int, info: map?{dateCreated: str, syncCount: int, totalEvents: int}}, substatus: str?, isPublic: bool, platform: str?, priority: str?, priorityLockedAt: str(date-time)?, seerFixabilityScore: num(double)?, seerAutofixLastTriggered: str(date-time)?, seerExplorerAutofixLastTriggered: str(date-time)?, project: map{id: str, name: str, slug: str, platform: str?}, type: str, issueType: str, issueCategory: str, metadata: map{title: str, value: str, type: str, synthetic: bool, filename: str, function: str, message: str, uri: str, directive: str, origin: str, name: str, contact_email: str, source: str, in_app_frame_mix: str, stripped_crash: bool, sdk: map{name: str, name_normalized: str}, severity: num(double), severity_reason: str, initial_priority: int}, numComments: int, assignedTo: map?{type: str, id: str, name: str, email: str}, isBookmarked: bool, isSubscribed: bool, subscriptionDetails: map?{disabled: bool, reason: str}, hasSeen: bool, annotations: [map], firstRelease: any, lastRelease: any, tags: [map], stats: map, inbox: map?{reason: int, reason_details: map?{until: str?, count: int?, window: int?, user_count: int?, user_window: int?}, date_added: str(date-time)}, owners: [map]?, forecast: map{data: [int], date_added: num(double)}, integrationIssues: [map], sentryAppIssues: [map], latestEventHasAttachments: bool, activity: [any], seenBy: [map], userReportCount: int, participants: [map]}
@errors {401, 403, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/issues/{issue_id}/
@required {issue_id: str}
@optional {inbox: bool, status: str(resolved/unresolved/ignored/resolvedInNextRelease/muted), statusDetails: any, substatus: str(archived_until_escalating/archived_until_condition_met/archived_forever/escalating/ongoing/regressed/new), hasSeen: bool, isBookmarked: bool, isPublic: bool, isSubscribed: bool, merge: bool, discard: bool, assignedTo: str, priority: str(low/medium/high), ignoreDuration: int, ignoreCount: int, ignoreWindow: int, ignoreUserCount: int, ignoreUserWindow: int, snoozeDuration: int}
@returns(200) {isUnhandled: bool, count: str, userCount: int, firstSeen: str(date-time)?, lastSeen: str(date-time)?, derivedData: map{blocker: str, progress: str, status: str, viewCount: int, hasOpenFixPr: bool, isAssigned: bool, hasRootCause: bool, lastCompletedAutofixStep: str, lastProgressedAt: str(date-time)?, impact: map?{score: num(double)?, level: str?, description: str, citations: [map], sourceEventId: str}}, id: str, shareId: str?, shortId: str?, title: str, culprit: str?, permalink: str(uri), logger: str?, level: str, status: str, statusDetails: map{ignoreCount: int?, ignoreUntil: str(date-time)?, ignoreUserCount: int?, ignoreUserWindow: int?, ignoreWindow: int?, actor: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [map], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, inNextRelease: bool, inRelease: str, inCommit: str, pendingEvents: int, info: map?{dateCreated: str, syncCount: int, totalEvents: int}}, substatus: str?, isPublic: bool, platform: str?, priority: str?, priorityLockedAt: str(date-time)?, seerFixabilityScore: num(double)?, seerAutofixLastTriggered: str(date-time)?, seerExplorerAutofixLastTriggered: str(date-time)?, project: map{id: str, name: str, slug: str, platform: str?}, type: str, issueType: str, issueCategory: str, metadata: map{title: str, value: str, type: str, synthetic: bool, filename: str, function: str, message: str, uri: str, directive: str, origin: str, name: str, contact_email: str, source: str, in_app_frame_mix: str, stripped_crash: bool, sdk: map{name: str, name_normalized: str}, severity: num(double), severity_reason: str, initial_priority: int}, numComments: int, assignedTo: map?{type: str, id: str, name: str, email: str}, isBookmarked: bool, isSubscribed: bool, subscriptionDetails: map?{disabled: bool, reason: str}, hasSeen: bool, annotations: [map]}
@errors {400, 401, 403, 404}

@endpoint DELETE /organizations/{organization_id_or_slug}/issues/{issue_id}/
@required {issue_id: str}
@returns(202)
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/issues/{issue_id}/autofix/
@required {issue_id: str}
@optional {llmFormat: str(json/markdown/xml)}
@returns(200) {formatted: map{format: str, content: str}, autofix: map?}
@errors {401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/issues/{issue_id}/autofix/
@required {issue_id: str}
@optional {step: str(root_cause/solution/code_changes/pr_iteration/open_pr/coding_agent_handoff)=root_cause, stopping_point: str(root_cause/solution/code_changes/open_pr), run_id: int, sentry_run_id: str(uuid), integration_id: int, provider: str, user_context: str, repo_name: str, insert_index: int, referrer: str}
@returns(202) {run_id: int, sentry_run_id: str?, feature_id: str}
@errors {400, 401, 402, 403, 404, 409}

@endpoint GET /organizations/{organization_id_or_slug}/issues/{issue_id}/events/
@required {issue_id: str}
@optional {start: str(date-time), end: str(date-time), statsPeriod: str, statsPeriodStart: str, statsPeriodEnd: str, environment: [str], full: bool=false, sample: bool=false, query: str, per_page: int, cursor: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/issues/{issue_id}/events/{event_id}/
@required {issue_id: str, event_id: str(latest/oldest/recommended)}
@optional {environment: [str], start: str(date-time), end: str(date-time), statsPeriod: str, statsPeriodStart: str, statsPeriodEnd: str, collapse: [str], llmFormat: str(json/markdown/xml)}
@returns(200) {id: str, groupID: str?, eventID: str, projectID: str, message: str?, title: str, location: str?, platform: str?, dateReceived: str(date-time)?, size: int?, entries: [any], dist: str?, packages: map, type: str, metadata: map{title: str, value: str, type: str, synthetic: bool, filename: str, function: str, message: str, uri: str, directive: str, origin: str, name: str, contact_email: str, source: str, in_app_frame_mix: str, stripped_crash: bool, sdk: map{name: str, name_normalized: str}, severity: num(double), severity_reason: str, initial_priority: int}, occurrence: any, _meta: map, user: map?{id: str?, email: str?, username: str?, ip_address: str?, name: str?, geo: map?, data: map?}, tags: [map], contexts: map?, sdk: map?{name: str?, version: str?}, context: map?, errors: [map], crashFile: str?, culprit: str?, dateCreated: str(date-time), fingerprints: [str], groupingConfig: map{id: str, enhancements: str}, startTimestamp: num(double), endTimestamp: num(double), measurements: map?, breakdowns: map?, release: map?{id: int, commitCount: int, data: map, dateCreated: str(date-time), dateReleased: str(date-time)?, deployCount: int, ref: str?, lastCommit: map?{id: str, message: str?, dateCreated: str(date-time), pullRequest: map?{id: str, title: str?, message: str?, dateCreated: str(date-time), mergedAt: str(date-time)?, status: str?, repository: map, author: any, externalUrl: str?}, suspectCommitType: str, repository: map{url: str?, provider: map, status: str, integrationId: str?, externalSlug: str?, externalId: str?, settings: map?, id: str, name: str, dateCreated: str(date-time)}, author: any}, lastDeploy: map?{dateStarted: str(date-time)?, url: str?, id: str, environment: str, dateFinished: str(date-time), name: str?}, status: str, url: str?, userAgent: str?, version: str?, versionInfo: map?{description: str, package: str?, version: map{major: int, minor: int, patch: int, pre: str?, buildCode: str?, components: int, raw: str}, buildHash: str?}}, userReport: map?{id: str, eventID: str, name: str?, email: str?, comments: str, dateCreated: str(date-time), user: map?{id: str, username: str?, email: str?, name: str?, ipAddress: str?, avatarUrl: str?}, event: map{id: str, eventID: str}}, sdkUpdates: [any], resolvedWith: [str], nextEventID: str?, previousEventID: str?, formatted: map{format: str, content: str}}
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/issues/{issue_id}/external-issues/
@required {issue_id: str}
@optional {cursor: str}
@returns(200)

@endpoint DELETE /organizations/{organization_id_or_slug}/issues/{issue_id}/external-issues/{external_issue_id}/
@required {issue_id: str, external_issue_id: str}
@returns(204)
@errors {401, 403, 404, 409}

@endpoint GET /organizations/{organization_id_or_slug}/issues/{issue_id}/hashes/
@required {issue_id: str}
@optional {full: bool=true, cursor: str}
@returns(200)
@errors {401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/issues/{issue_id}/integrations/
@required {issue_id: str}
@optional {cursor: str, per_page: int}
@returns(200)

@endpoint GET /organizations/{organization_id_or_slug}/issues/{issue_id}/integrations/{integration_id}/
@required {issue_id: str, integration_id: str, action: str(create/link)}
@returns(200) {id: str, name: str, icon: str?, domainName: str?, accountType: str?, scopes: [str]?, outOfDate: bool?, missingFeatures: [map]?, status: str, provider: map{key: str, slug: str, name: str, canAdd: bool, canDisable: bool, features: [str], aspects: map{alerts: [map], configure_integration: map{title: str}, directEnable: bool, disable_dialog: map{actionText: str, body: str}, externalInstall: map{url: str, buttonText: str, noticeText: str}, removal_dialog: map{actionText: str, body: str}}}, linkIssueConfig: [map], createIssueConfig: [map]}
@errors {400, 401, 403, 404}

@endpoint POST /organizations/{organization_id_or_slug}/issues/{issue_id}/integrations/{integration_id}/
@required {issue_id: str, integration_id: str, title: str}
@optional {description: str}
@returns(201) {id: int, key: str, url: str, integrationId: int, displayName: str}
@errors {400, 401, 404}

@endpoint PUT /organizations/{organization_id_or_slug}/issues/{issue_id}/integrations/{integration_id}/
@required {issue_id: str, integration_id: str, externalIssue: str}
@optional {repo: str, comment: str}
@returns(200) {id: int, key: str, url: str, integrationId: int, displayName: str}
@returns(201) {id: int, key: str, url: str, integrationId: int, displayName: str}
@errors {400, 401, 404, 409}

@endpoint DELETE /organizations/{organization_id_or_slug}/issues/{issue_id}/integrations/{integration_id}/
@required {issue_id: str, integration_id: str, externalIssue: int}
@returns(204)
@errors {400, 403, 404, 409}

@endpoint GET /organizations/{organization_id_or_slug}/issues/{issue_id}/tags/{key}/
@required {issue_id: str, key: str}
@optional {environment: [str]}
@returns(200) {uniqueValues: int?, totalValues: int?, topValues: [map]?, key: str, name: str}
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/issues/{issue_id}/tags/{key}/values/
@required {issue_id: str, key: str}
@optional {sort: str(age/count/date/id), environment: [str]}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /organizations/{organization_id_or_slug}/shared/issues/{share_id}/
@required {share_id: str}
@returns(200) {culprit: str?, id: str, isUnhandled: bool?, issueCategory: str, permalink: str(uri), shortId: str?, title: str, latestEvent: map?{id: str, groupID: str?, eventID: str, projectID: str, message: str?, title: str, location: str?, platform: str?, dateReceived: str(date-time)?, size: int?, entries: [any], dist: str?, packages: map, type: str, metadata: map{title: str, value: str, type: str, synthetic: bool, filename: str, function: str, message: str, uri: str, directive: str, origin: str, name: str, contact_email: str, source: str, in_app_frame_mix: str, stripped_crash: bool, sdk: map{name: str, name_normalized: str}, severity: num(double), severity_reason: str, initial_priority: int}, occurrence: any, _meta: map, crashFile: str?, culprit: str?, dateCreated: str(date-time), fingerprints: [str], groupingConfig: map{id: str, enhancements: str}, startTimestamp: num(double), endTimestamp: num(double), measurements: map?, breakdowns: map?}, project: map{slug: str, name: str, color: str, features: [str], organization: map{slug: str, name: str}}}
@errors {404}

@endgroup

@end
