@lap v0.3
# Machine-readable API spec. Each @endpoint block is one API call.
@api API Reference
@base https://us.sentry.io
@version v0
@auth Bearer bearer | Bearer DSN
@common_fields {organization_id_or_slug: str}
@endpoints 218
@hint download_for_search
@toc api(218)

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

@endpoint GET /api/0/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 /api/0/organizations/{organization_id_or_slug}/
@optional {slug: str, name: str, isEarlyAdopter: bool, hideAiFeatures: bool, codecovAccess: 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], githubPRBot: bool, githubNudgeInvite: bool, gitlabPRBot: bool, issueAlertsThreadFlag: bool, metricAlertsThreadFlag: bool, cancelDeletion: bool}
@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: any, orgRole: str, targetSampleRate: num(double), samplingMode: 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?, trustedRelays: [map], pendingAccessRequests: int, codecovAccess: bool, hideAiFeatures: bool, githubPRBot: bool, githubNudgeInvite: bool, gitlabPRBot: bool, aggregatedDataConsent: bool, isDynamicallySampled: bool, issueAlertsThreadFlag: bool, metricAlertsThreadFlag: bool, requiresSso: bool, defaultAutofixAutomationTuning: str, defaultSeerScannerAutomation: bool, enableSeerEnhancedAlerts: bool, enableSeerCoding: bool, defaultCodingAgent: str, defaultCodingAgentIntegrationId: int?, defaultAutomatedRunStoppingPoint: str, autoEnableCodeReview: bool, autoOpenPrs: bool, defaultCodeReviewTriggers: [str], teams: [map], projects: [map]}
@errors {400, 401, 403, 404, 409, 413}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/alert-rules/
@returns(200)
@errors {401, 403, 404}

@endpoint POST /api/0/organizations/{organization_id_or_slug}/alert-rules/
@required {name: str, aggregate: str, timeWindow: int(1/5/10/15/30/60/120/240/1440), projects: [str], query: str, thresholdType: int(0/1), triggers: [any]}
@optional {environment: str, dataset: str, queryType: int(0/1/2), eventTypes: [str], comparisonDelta: int, resolveThreshold: num(double), owner: str}
@returns(201) {environment: str?, projects: [str]?, queryType: int?, resolveThreshold: num(double)?, dataset: str?, thresholdType: int?, eventTypes: [str]?, owner: str?, originalAlertRuleId: str?, comparisonDelta: num(double)?, snooze: bool?, errors: [str]?, extrapolationMode: str?, id: str, name: str, organizationId: str, query: str, aggregate: str, timeWindow: num(double), triggers: [map], dateModified: str(date-time), dateCreated: str(date-time), createdBy: map}
@errors {401, 403, 404}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/alert-rules/{alert_rule_id}/
@required {alert_rule_id: int}
@returns(200) {environment: str?, projects: [str]?, queryType: int?, resolveThreshold: num(double)?, dataset: str?, thresholdType: int?, eventTypes: [str]?, owner: str?, originalAlertRuleId: str?, comparisonDelta: num(double)?, snooze: bool?, errors: [str]?, extrapolationMode: str?, id: str, name: str, organizationId: str, query: str, aggregate: str, timeWindow: num(double), triggers: [map], dateModified: str(date-time), dateCreated: str(date-time), createdBy: map}
@errors {401, 403, 404}

@endpoint PUT /api/0/organizations/{organization_id_or_slug}/alert-rules/{alert_rule_id}/
@required {alert_rule_id: int, name: str, aggregate: str, timeWindow: int(1/5/10/15/30/60/120/240/1440), projects: [str], query: str, thresholdType: int(0/1), triggers: [any]}
@optional {environment: str, dataset: str, queryType: int(0/1/2), eventTypes: [str], comparisonDelta: int, resolveThreshold: num(double), owner: str}
@returns(200) {environment: str?, projects: [str]?, queryType: int?, resolveThreshold: num(double)?, dataset: str?, thresholdType: int?, eventTypes: [str]?, owner: str?, originalAlertRuleId: str?, comparisonDelta: num(double)?, snooze: bool?, errors: [str]?, extrapolationMode: str?, id: str, name: str, organizationId: str, query: str, aggregate: str, timeWindow: num(double), triggers: [map], dateModified: str(date-time), dateCreated: str(date-time), createdBy: map}
@errors {401, 403, 404}

@endpoint DELETE /api/0/organizations/{organization_id_or_slug}/alert-rules/{alert_rule_id}/
@required {alert_rule_id: int}
@returns(202)
@errors {401, 403, 404}

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

@endpoint GET /api/0/organizations/{organization_id_or_slug}/dashboards/
@optional {per_page: int, cursor: str}
@returns(200)
@errors {400, 403, 404}

@endpoint POST /api/0/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, 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, createdBy: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [any], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: 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?}
@errors {400, 403, 404, 409}

@endpoint GET /api/0/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, createdBy: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [any], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: 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?}
@errors {403, 404}

@endpoint PUT /api/0/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}
@returns(200) {environment: [str], period: str, utc: str, expired: bool, start: str(date-time), end: str(date-time), id: str, title: str, dateCreated: str, createdBy: map?{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [any], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: 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?}
@errors {400, 403, 404}

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

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

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

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

@endpoint GET /api/0/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?, description: str?, id: str, projectId: str, name: str, type: str, workflowIds: [str]?, dateCreated: str(date-time), dateUpdated: str(date-time), dataSources: [map]?, conditionGroup: map?, config: map, enabled: bool, openIssues: int}
@errors {400, 401, 403, 404}

@endpoint PUT /api/0/organizations/{organization_id_or_slug}/detectors/{detector_id}/
@required {detector_id: int, name: str, type: str}
@optional {workflow_ids: [int], data_sources: [any], config: map, condition_group: any, owner: str, description: str, enabled: bool}
@returns(200) {owner: map?{type: str, id: str, name: str, email: str}, createdBy: str?, latestGroup: map?, description: str?, id: str, projectId: str, name: str, type: str, workflowIds: [str]?, dateCreated: str(date-time), dateUpdated: str(date-time), dataSources: [map]?, conditionGroup: map?, config: map, enabled: bool, openIssues: int}
@errors {400, 401, 403, 404}

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

@endpoint GET /api/0/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 /api/0/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, environment: [str], query: 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, id: str, name: str, projects: [int], version: int, queryDataset: str, datasetSource: str, expired: bool, dateCreated: str, dateUpdated: str, createdBy: map{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [any], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: 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 /api/0/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, id: str, name: str, projects: [int], version: int, queryDataset: str, datasetSource: str, expired: bool, dateCreated: str, dateUpdated: str, createdBy: map{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [any], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: 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 /api/0/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, environment: [str], query: 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, id: str, name: str, projects: [int], version: int, queryDataset: str, datasetSource: str, expired: bool, dateCreated: str, dateUpdated: str, createdBy: map{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [any], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: 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 /api/0/organizations/{organization_id_or_slug}/discover/saved/{query_id}/
@required {query_id: int}
@returns(204)
@errors {403, 404}

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

@endpoint GET /api/0/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?, user: map?{id: str?, email: str?, username: str?, ip_address: str?, name: str?, geo: map?, data: map?}, tags: [map], platform: str, dateReceived: str(date-time)?, contexts: map?, size: int?, entries: [any], dist: str?, sdk: map, context: map?, packages: map, type: str, metadata: any, errors: [any], occurrence: any, _meta: map, crashFile: str?, culprit: str?, dateCreated: str(date-time), fingerprints: [str], groupingConfig: any, startTimestamp: str(date-time), endTimestamp: str(date-time), measurements: any, breakdowns: any}}
@errors {404}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/events/
@required {field: [str], dataset: str(logs/profile_functions/spans/uptime_results)}
@optional {end: str(date-time), environment: [str], project: [int], start: str(date-time), statsPeriod: str, per_page: int, query: str, sort: str}
@returns(200) {data: [map], meta: map{fields: map, datasetReason: str, isMetricsData: bool, isMetricsExtractedData: bool}}
@errors {400, 404}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/events-timeseries/
@required {dataset: str(logs/profile_functions/spans/uptime_results)}
@optional {end: str(date-time), environment: [str], project: [int], start: str(date-time), statsPeriod: str, topEvents: int, comparisonDelta: int, interval: int, sort: str, groupBy: [str], yAxis: 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)}, timeSeries: [map]}
@errors {400, 404}

@endpoint POST /api/0/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/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 /api/0/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/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 /api/0/organizations/{organization_id_or_slug}/external-users/{external_user_id}/
@required {external_user_id: int}
@returns(204)
@errors {400, 403}

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

@endpoint POST /api/0/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 /api/0/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 /api/0/organizations/{organization_id_or_slug}/forwarding/{data_forwarder_id}/
@required {data_forwarder_id: int}
@returns(204)
@errors {403}

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

@endpoint GET /api/0/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]?, status: str, provider: any, configOrganization: any, configData: any, externalId: str, organizationId: int, organizationIntegrationStatus: str, gracePeriodEnd: str?}

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

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

@endpoint PUT /api/0/organizations/{organization_id_or_slug}/issues/
@required {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)}
@optional {environment: [str], project: [int], id: [int], query: str=is:unresolved, viewId: str, sort: str(date/freq/inbox/new/trends/user)=date, limit: int=100}
@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 /api/0/organizations/{organization_id_or_slug}/issues/
@optional {environment: [str], project: [int], id: [int], query: str=is:unresolved, viewId: str, sort: str(date/freq/inbox/new/trends/user)=date, limit: int=100}
@returns(204)
@errors {400, 401, 403, 404}

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

@endpoint POST /api/0/organizations/{organization_id_or_slug}/members/
@required {email: str(email)}
@optional {orgRole: str(billing/member/manager/owner/admin)=member, teamRoles: [map], sendInvite: bool=true, reinvite: bool}
@returns(201) {externalUsers: [map], id: str, email: str, name: str, user: map{identities: [map], avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [any], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: 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 {401, 403, 404}

@endpoint GET /api/0/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: [any], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: 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], invite_link: str?, isOnlyOwner: bool, orgRoleList: [map], teamRoleList: [map]}
@errors {401, 403, 404}

@endpoint PUT /api/0/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: [any], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: 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], invite_link: str?, isOnlyOwner: bool, orgRoleList: [map], teamRoleList: [map]}
@errors {400, 401, 403}

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

@endpoint POST /api/0/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 /api/0/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 /api/0/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 /api/0/organizations/{organization_id_or_slug}/monitors/
@optional {project: [int], environment: [str], owner: str, cursor: str}
@returns(200)
@errors {401, 403, 404}

@endpoint POST /api/0/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) {alertRule: map{targets: [map], environment: str}, 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: any, sessionStats: any, 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{name: str, status: str, isMuted: bool, dateCreated: str(date-time), lastCheckIn: str(date-time), nextCheckIn: str(date-time), nextCheckInLatest: str(date-time), activeIncident: map?{startingTimestamp: str(date-time), resolvingTimestamp: str(date-time), brokenNotice: map?{userNotifiedTimestamp: str(date-time), environmentMutedTimestamp: str(date-time)}}}, owner: map{type: str, id: str, name: str, email: str}}
@errors {400, 401, 403, 404}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/monitors/{monitor_id_or_slug}/
@required {monitor_id_or_slug: str}
@optional {environment: [str]}
@returns(200) {alertRule: map{targets: [map], environment: str}, 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: any, sessionStats: any, 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{name: str, status: str, isMuted: bool, dateCreated: str(date-time), lastCheckIn: str(date-time), nextCheckIn: str(date-time), nextCheckInLatest: str(date-time), activeIncident: map?{startingTimestamp: str(date-time), resolvingTimestamp: str(date-time), brokenNotice: map?{userNotifiedTimestamp: str(date-time), environmentMutedTimestamp: str(date-time)}}}, owner: map{type: str, id: str, name: str, email: str}}
@errors {401, 403, 404}

@endpoint PUT /api/0/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) {alertRule: map{targets: [map], environment: str}, 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: any, sessionStats: any, 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{name: str, status: str, isMuted: bool, dateCreated: str(date-time), lastCheckIn: str(date-time), nextCheckIn: str(date-time), nextCheckInLatest: str(date-time), activeIncident: map?{startingTimestamp: str(date-time), resolvingTimestamp: str(date-time), brokenNotice: map?{userNotifiedTimestamp: str(date-time), environmentMutedTimestamp: str(date-time)}}}, owner: map{type: str, id: str, name: str, email: str}}
@errors {400, 401, 403, 404}

@endpoint DELETE /api/0/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 /api/0/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 GET /api/0/organizations/{organization_id_or_slug}/notifications/actions/
@optional {project: [int], project_id_or_slug: [str], triggerType: str}
@returns(201)
@errors {400, 403}

@endpoint POST /api/0/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]}
@returns(201)
@errors {400, 403}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/notifications/actions/{action_id}/
@required {action_id: int}
@returns(200)

@endpoint PUT /api/0/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]}
@returns(202)
@errors {400}

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

@endpoint GET /api/0/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?, dateBuilt: str?}, 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?, downloadCount: int, releaseNotes: str?, installGroups: [str]?, isCodeSignatureValid: bool?, profileName: str?, codesigningType: str?}
@errors {403, 404}

@endpoint GET /api/0/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?, dateBuilt: str?}, 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?, dateBuilt: str?}, insights: map?, appComponents: [map]?, comparisons: [map]?}
@errors {400, 403, 404}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/prevent/owner/{owner}/repositories/
@required {owner: str}
@optional {limit: int, navigation: str, cursor: str, term: str}
@returns(200) {results: [map], pageInfo: map{endCursor: str?, startCursor: str?, hasPreviousPage: bool, hasNextPage: bool}, totalCount: int}
@errors {400, 403, 404}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/prevent/owner/{owner}/repositories/sync/
@required {owner: str}
@returns(200) {isSyncing: bool}
@errors {400, 403, 404}

@endpoint POST /api/0/organizations/{organization_id_or_slug}/prevent/owner/{owner}/repositories/sync/
@required {owner: str}
@returns(200) {isSyncing: bool}
@errors {400, 403, 404}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/prevent/owner/{owner}/repositories/tokens/
@required {owner: str}
@optional {limit: int, navigation: str, cursor: str, sortBy: str}
@returns(200) {results: [map], pageInfo: map{endCursor: str?, startCursor: str?, hasPreviousPage: bool, hasNextPage: bool}, totalCount: int}
@errors {400, 403, 404}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/prevent/owner/{owner}/repository/{repository}/
@required {owner: str, repository: str}
@returns(200) {uploadToken: str?, testAnalyticsEnabled: bool}
@errors {400, 403, 404}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/prevent/owner/{owner}/repository/{repository}/branches/
@required {owner: str, repository: str}
@optional {limit: int, navigation: str, cursor: str, term: str}
@returns(200) {defaultBranch: str, results: [map], pageInfo: map{endCursor: str?, startCursor: str?, hasPreviousPage: bool, hasNextPage: bool}, totalCount: int}
@errors {400, 403, 404}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/prevent/owner/{owner}/repository/{repository}/test-results/
@required {owner: str, repository: str}
@optional {sortBy: str, filterBy: str, interval: str, branch: str, limit: int, navigation: str, cursor: str, term: str}
@returns(200) {defaultBranch: str, results: [map], pageInfo: map{endCursor: str?, startCursor: str?, hasPreviousPage: bool, hasNextPage: bool}, totalCount: int}
@errors {400, 403, 404}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/prevent/owner/{owner}/repository/{repository}/test-results-aggregates/
@required {owner: str, repository: str}
@optional {interval: str, branch: str}
@returns(200) {totalDuration: num(double), totalDurationPercentChange: num(double), slowestTestsDuration: num(double), slowestTestsDurationPercentChange: num(double), totalSlowTests: int, totalSlowTestsPercentChange: num(double), totalFails: int, totalFailsPercentChange: num(double), totalSkips: int, totalSkipsPercentChange: num(double), flakeCount: int, flakeCountPercentChange: num(double), flakeRate: num(double), flakeRatePercentChange: num(double)}
@errors {400, 403, 404}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/prevent/owner/{owner}/repository/{repository}/test-suites/
@required {owner: str, repository: str}
@optional {term: str}
@returns(200) {testSuites: [str]}
@errors {400, 403, 404}

@endpoint POST /api/0/organizations/{organization_id_or_slug}/prevent/owner/{owner}/repository/{repository}/token/regenerate/
@required {owner: str, repository: str}
@returns(200) {token: str}
@errors {400, 403, 404}

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

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

@endpoint POST /api/0/organizations/{organization_id_or_slug}/projects/{project_id_or_slug}/detectors/
@required {project_id_or_slug: str, name: str, type: str}
@optional {workflow_ids: [int], data_sources: [any], config: map, condition_group: any, owner: str, description: str, enabled: bool}
@returns(201) {owner: map?{type: str, id: str, name: str, email: str}, createdBy: str?, latestGroup: map?, description: str?, id: str, projectId: str, name: str, type: str, workflowIds: [str]?, dateCreated: str(date-time), dateUpdated: str(date-time), dataSources: [map]?, conditionGroup: map?, config: map, enabled: bool, openIssues: int}
@errors {400, 401, 403, 404}

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

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

@endpoint GET /api/0/organizations/{organization_id_or_slug}/releases/{version}/
@required {version: str}
@optional {project_id: str, 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(crash_free_sessions/crash_free_users/date/sessions/users), 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?, lastCommit: map?, lastDeploy: map?{dateStarted: str?, url: str?, id: str, environment: str, dateFinished: str, name: str}, firstEvent: str(date-time)?, lastEvent: str(date-time)?, currentProjectMeta: map?, userAgent: str?, adoptionStages: map?, id: int, version: str, newGroups: int, status: str, shortVersion: str, versionInfo: map?{description: str, package: str?, version: map, buildHash: str?}, data: map, commitCount: int, deployCount: int, authors: [map], projects: [map]}
@errors {401, 403, 404}

@endpoint PUT /api/0/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]}], 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?, lastCommit: map?, lastDeploy: map?{dateStarted: str?, url: str?, id: str, environment: str, dateFinished: str, name: str}, firstEvent: str(date-time)?, lastEvent: str(date-time)?, currentProjectMeta: map?, userAgent: str?, adoptionStages: map?, id: int, version: str, newGroups: int, status: str, shortVersion: str, versionInfo: map?{description: str, package: str?, version: map, buildHash: str?}, data: map, commitCount: int, deployCount: int, authors: [map], projects: [map]}
@errors {401, 403, 404}

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

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

@endpoint POST /api/0/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 /api/0/organizations/{organization_id_or_slug}/replay-count/
@optional {environment: [str], start: str(date-time), end: str(date-time), statsPeriod: str, project_id_or_slug: [str], query: str}
@returns(200)
@errors {400, 403}

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

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

@endpoint GET /api/0/organizations/{organization_id_or_slug}/replays/{replay_id}/
@required {replay_id: str(uuid)}
@optional {statsPeriod: str, start: str(date-time), end: str(date-time), field: [str], project: [int], projectSlug: [str], environment: str, sort: str, sortBy: str, orderBy: str, query: str, per_page: int, cursor: str}
@returns(200) {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]?, 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 /api/0/organizations/{organization_id_or_slug}/repos/{repo_id}/commits/
@required {repo_id: str}
@optional {cursor: str}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /api/0/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 /api/0/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 {401, 403, 404}

@endpoint GET /api/0/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 /api/0/organizations/{organization_id_or_slug}/scim/v2/Groups/{team_id_or_slug}
@required {team_id_or_slug: str, Operations: [map{op!: str, value: map, path: str}]}
@returns(204)
@errors {401, 403, 404}

@endpoint DELETE /api/0/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 /api/0/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 /api/0/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 /api/0/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 /api/0/organizations/{organization_id_or_slug}/scim/v2/Users/{member_id}
@required {member_id: str, Operations: [map{op!: str, value!: any, path: str}]}
@returns(204)
@errors {401, 403, 404}

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

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

@endpoint GET /api/0/organizations/{organization_id_or_slug}/sessions/
@required {field: [str]}
@optional {start: str(date-time), end: str(date-time), environment: [str], statsPeriod: str, project: [int], 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 /api/0/organizations/{organization_id_or_slug}/shortids/{issue_id}/
@required {issue_id: 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)?, id: str, shareId: str, shortId: str, title: str, culprit: str?, permalink: str, logger: str?, level: str, status: str, statusDetails: map{autoResolved: bool, ignoreCount: int, ignoreUntil: str(date-time), ignoreUserCount: int, ignoreUserWindow: int, ignoreWindow: int, actor: map{identities: [map], avatar: map, authenticators: [any], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: 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: any}, 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, 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 GET /api/0/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 /api/0/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 /api/0/organizations/{organization_id_or_slug}/teams/
@optional {detailed: str, cursor: str}
@returns(200)
@errors {403, 404}

@endpoint POST /api/0/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}

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

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

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

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

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

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

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

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

@endpoint GET /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/
@required {project_id_or_slug: str}
@returns(200) {stats: any, transactionStats: any, sessionStats: any, 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, 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}, plugins: [map], platforms: [str], processingIssues: int, defaultEnvironment: str?, relayPiiConfig: str?, builtinSymbolSources: [str], dynamicSamplingBiases: [map], symbolSources: str, isDynamicallySampled: bool, tempestFetchScreenshots: bool, autofixAutomationTuning: str, seerScannerAutomation: bool, scmSourceContextEnabled: bool, debugFilesRole: str?}
@errors {403, 404}

@endpoint PUT /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/
@required {project_id_or_slug: str}
@optional {isBookmarked: bool, name: str, slug: str, platform: str, subjectPrefix: str, subjectTemplate: str, resolveAge: int, highlightContext: map, highlightTags: [str], scmSourceContextEnabled: bool}
@returns(200) {stats: any, transactionStats: any, sessionStats: any, 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, 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}, plugins: [map], platforms: [str], processingIssues: int, defaultEnvironment: str?, relayPiiConfig: str?, builtinSymbolSources: [str], dynamicSamplingBiases: [map], symbolSources: str, isDynamicallySampled: bool, tempestFetchScreenshots: bool, autofixAutomationTuning: str, seerScannerAutomation: bool, scmSourceContextEnabled: bool, debugFilesRole: str?}
@errors {403, 404}

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

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

@endpoint GET /api/0/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 /api/0/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 /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/events/
@required {project_id_or_slug: str}
@optional {statsPeriod: 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 /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/events/{event_id}/source-map-debug/
@required {project_id_or_slug: str, event_id: str(uuid), frame_idx: int, exception_idx: int}
@returns(200) {errors: [map]}
@errors {401, 403, 404}

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

@endpoint PUT /api/0/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 /api/0/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 /api/0/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, public: str, csp: str, security: str, minidump: str, nel: str, unreal: str, crons: str, cdn: str, playstation: str, integration: str, otlp_traces: str, otlp_logs: str}, 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 /api/0/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, public: str, csp: str, security: str, minidump: str, nel: str, unreal: str, crons: str, cdn: str, playstation: str, integration: str, otlp_traces: str, otlp_logs: str}, 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 /api/0/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, public: str, csp: str, security: str, minidump: str, nel: str, unreal: str, crons: str, cdn: str, playstation: str, integration: str, otlp_traces: str, otlp_logs: str}, 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 /api/0/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 /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/members/
@required {project_id_or_slug: str}
@returns(200)
@errors {400, 403}

@endpoint GET /api/0/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) {alertRule: map{targets: [map], environment: str}, 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: any, sessionStats: any, 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{name: str, status: str, isMuted: bool, dateCreated: str(date-time), lastCheckIn: str(date-time), nextCheckIn: str(date-time), nextCheckInLatest: str(date-time), activeIncident: map?{startingTimestamp: str(date-time), resolvingTimestamp: str(date-time), brokenNotice: map?{userNotifiedTimestamp: str(date-time), environmentMutedTimestamp: str(date-time)}}}, owner: map{type: str, id: str, name: str, email: str}}
@errors {401, 403, 404}

@endpoint PUT /api/0/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) {alertRule: map{targets: [map], environment: str}, 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: any, sessionStats: any, 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{name: str, status: str, isMuted: bool, dateCreated: str(date-time), lastCheckIn: str(date-time), nextCheckIn: str(date-time), nextCheckInLatest: str(date-time), activeIncident: map?{startingTimestamp: str(date-time), resolvingTimestamp: str(date-time), brokenNotice: map?{userNotifiedTimestamp: str(date-time), environmentMutedTimestamp: str(date-time)}}}, owner: map{type: str, id: str, name: str, email: str}}
@errors {400, 401, 403, 404}

@endpoint DELETE /api/0/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 /api/0/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 /api/0/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 /api/0/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(202) {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 /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/preprodartifacts/build-distribution/latest/
@required {project_id_or_slug: str, appId: str, platform: str}
@optional {buildVersion: str, buildNumber: int, 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?, dateBuilt: str?}, 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?, 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?, dateBuilt: str?}, 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?, downloadCount: int, releaseNotes: str?, installGroups: [str]?, isCodeSignatureValid: bool?, profileName: str?, codesigningType: str?}}
@errors {400, 403}

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

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

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

@endpoint GET /api/0/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(uuid), segment_id: int}
@returns(200)
@errors {400, 403, 404}

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

@endpoint GET /api/0/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 /api/0/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, dateUpdated: str, rangeStart: str, rangeEnd: str, environments: [str], status: str, query: str, countDeleted: int}}
@errors {400, 403}

@endpoint GET /api/0/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, dateUpdated: str, rangeStart: str, rangeEnd: str, environments: [str], status: str, query: str, countDeleted: int}}
@errors {403, 404}

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

@endpoint POST /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/rules/
@required {project_id_or_slug: str, name: str, frequency: int, actionMatch: str(all/any/none), conditions: [map], actions: [map]}
@optional {environment: str, owner: str, filterMatch: str(all/any/none), filters: [map]}
@returns(201) {owner: str?, createdBy: map?{id: int, name: str, email: str}, environment: str?, lastTriggered: str?, snoozeCreatedBy: str?, snoozeForEveryone: bool?, disableReason: str, disableDate: str, errors: [map], id: str?, conditions: [map], filters: [map], actions: [map], actionMatch: str, filterMatch: str, frequency: int, name: str, dateCreated: str(date-time), projects: [str], status: str, snooze: bool}
@errors {401, 403, 404}

@endpoint GET /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/rules/{rule_id}/
@required {project_id_or_slug: str, rule_id: int}
@returns(200) {owner: str?, createdBy: map?{id: int, name: str, email: str}, environment: str?, lastTriggered: str?, snoozeCreatedBy: str?, snoozeForEveryone: bool?, disableReason: str, disableDate: str, errors: [map], id: str?, conditions: [map], filters: [map], actions: [map], actionMatch: str, filterMatch: str, frequency: int, name: str, dateCreated: str(date-time), projects: [str], status: str, snooze: bool}
@errors {401, 403, 404}

@endpoint PUT /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/rules/{rule_id}/
@required {project_id_or_slug: str, rule_id: int, name: str, actionMatch: str(all/any/none), conditions: [map], actions: [map], frequency: int}
@optional {environment: str, filterMatch: str(all/any/none), filters: [map], owner: str}
@returns(200) {owner: str?, createdBy: map?{id: int, name: str, email: str}, environment: str?, lastTriggered: str?, snoozeCreatedBy: str?, snoozeForEveryone: bool?, disableReason: str, disableDate: str, errors: [map], id: str?, conditions: [map], filters: [map], actions: [map], actionMatch: str, filterMatch: str, frequency: int, name: str, dateCreated: str(date-time), projects: [str], status: str, snooze: bool}
@errors {401, 403, 404}

@endpoint DELETE /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/rules/{rule_id}/
@required {project_id_or_slug: str, rule_id: int}
@returns(202)
@errors {401, 403, 404}

@endpoint GET /api/0/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 /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/symbol-sources/
@required {project_id_or_slug: str, type: str(http/gcs/s3), 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}
@returns(201)
@errors {400, 403}

@endpoint PUT /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/symbol-sources/
@required {project_id_or_slug: str, id: str, type: str(http/gcs/s3), 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}
@returns(200)
@errors {400, 403, 404}

@endpoint DELETE /api/0/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 /api/0/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 /api/0/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: any, sessionStats: any, 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 /api/0/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: any, sessionStats: any, 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 /api/0/seer/models/
@returns(200) {models: [str]}

@endpoint GET /api/0/sentry-apps/{sentry_app_id_or_slug}/
@required {sentry_app_id_or_slug: str}
@returns(200) {allowedOrigins: [str], avatars: [map], events: [str], featureData: [str], isAlertable: bool, metadata: str, name: str, schema: str, scopes: [str], slug: str, status: str, uuid: str, verifyInstall: 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 /api/0/sentry-apps/{sentry_app_id_or_slug}/
@required {sentry_app_id_or_slug: str, name: str, scopes: [str]}
@optional {author: str, events: [str], schema: map, webhookUrl: str(uri), redirectUrl: str(uri), isInternal: bool=false, isAlertable: bool=false, overview: str, verifyInstall: bool=true, allowedOrigins: [str]}
@returns(200) {allowedOrigins: [str], avatars: [map], events: [str], featureData: [str], isAlertable: bool, metadata: str, name: str, schema: str, scopes: [str], slug: str, status: str, uuid: str, verifyInstall: 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 /api/0/sentry-apps/{sentry_app_id_or_slug}/
@required {sentry_app_id_or_slug: str}
@returns(204)
@errors {403}

@endpoint GET /api/0/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 /api/0/teams/{organization_id_or_slug}/{team_id_or_slug}/
@required {team_id_or_slug: str, 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?}, 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 DELETE /api/0/teams/{organization_id_or_slug}/{team_id_or_slug}/
@required {team_id_or_slug: str}
@returns(204)
@errors {403, 404}

@endpoint POST /api/0/teams/{organization_id_or_slug}/{team_id_or_slug}/external-teams/
@required {team_id_or_slug: str, external_name: str, provider: str(github/github_enterprise/jira_server/slack/slack_staging/perforce/gitlab/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 /api/0/teams/{organization_id_or_slug}/{team_id_or_slug}/external-teams/{external_team_id}/
@required {team_id_or_slug: str, external_team_id: int, external_name: str, provider: str(github/github_enterprise/jira_server/slack/slack_staging/perforce/gitlab/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 /api/0/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 /api/0/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 /api/0/teams/{organization_id_or_slug}/{team_id_or_slug}/projects/
@required {team_id_or_slug: str}
@optional {cursor: str}
@returns(200)
@errors {403, 404}

@endpoint POST /api/0/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: any, sessionStats: any, 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}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/repos/
@optional {cursor: str}
@returns(200)
@errors {403, 404}

@endpoint GET /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/files/dsyms/
@required {project_id_or_slug: str}
@returns(200)
@errors {403, 404}

@endpoint POST /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/files/dsyms/
@required {project_id_or_slug: str}
@returns(201)
@errors {400, 403, 404}

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

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

@endpoint GET /api/0/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 /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/stats/
@required {project_id_or_slug: str}
@optional {stat: str(received/rejected/blacklisted/generated), since: str(date-time), until: str(date-time), resolution: str(10s/1h/1d)}
@returns(200)
@errors {403}

@endpoint GET /api/0/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 /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/user-feedback/
@required {project_id_or_slug: str, event_id: str, name: str, email: str, comments: str}
@returns(200) {comments: str, dateCreated: str, email: str, event: map{eventID: str, id: str?}, eventID: str, id: str, issue: map?, name: str, user: map?}
@errors {400, 403, 404, 409}

@endpoint GET /api/0/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 /api/0/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 /api/0/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 /api/0/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 /api/0/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 /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/events/{event_id}/
@required {project_id_or_slug: str, event_id: str}
@returns(200) {eventID: str, dist: str?, userReport: map?, previousEventID: str?, message: str, id: str, size: int, errors: [map], platform: str, nextEventID: str?, type: str, metadata: any, tags: [map], dateCreated: str, dateReceived: str, user: map?{username: str?, name: str?, ip_address: str?, email: str?, data: map?{isStaff: bool}, id: str}, entries: [any], packages: map, sdk: map{version: str, name: str}, _meta: map{user: str?, context: str?, entries: map, contexts: str?, message: str?, packages: str?, tags: map, sdk: str?}, contexts: map{ForbiddenError: map{status: int, statusText: str, responseJSON: map{detail: str}, type: str}, browser: map{version: str, type: str, name: str}, os: map{version: str, type: str, name: str}, trace: map{span_id: str, type: str, trace_id: str, op: str}, organization: map{type: str, id: str, slug: str}}, fingerprints: [str], context: map{resp: map{status: int, responseJSON: map{detail: str}, name: str, statusText: str, message: str, stack: str}, session: map{foo: str}, unauthorized: bool, url: str}, release: map?, groupID: str, title: str}
@errors {403}

@endpoint GET /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/issues/
@required {project_id_or_slug: str}
@optional {statsPeriod: str, shortIdLookup: bool, query: str, hashes: str, cursor: str}
@returns(200)
@errors {403}

@endpoint PUT /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/issues/
@required {project_id_or_slug: str}
@optional {id: int, status: 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}
@errors {400, 403, 404}

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

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

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

@endpoint GET /api/0/organizations/{organization_id_or_slug}/issues/{issue_id}/
@required {issue_id: str}
@returns(200) {activity: [map], annotations: [map], assignedTo: map?, count: str, culprit: str, firstRelease: map?{authors: [str], commitCount: int, data: map?, dateCreated: str, dateReleased: str?, deployCount: int, firstEvent: str, lastCommit: str?, lastDeploy: str?, lastEvent: str, newGroups: int, owner: str?, projects: [map], ref: str?, shortVersion: str, url: str?, version: str}, firstSeen: str, hasSeen: bool, id: str, isBookmarked: bool, isPublic: bool, isSubscribed: bool, lastRelease: map?, lastSeen: str, level: str, logger: str?, metadata: any, numComments: int, participants: [map], permalink: str, pluginActions: [[str]], pluginContexts: [str], pluginIssues: [map], project: map{id: str, name: str, slug: str}, seenBy: [map], shareId: str?, shortId: str, stats: map{24h: [[num]], 30d: [[num]]}, status: str, statusDetails: map, subscriptionDetails: map?, tags: [map], title: str, type: str, userCount: int, userReportCount: int}
@errors {403}

@endpoint PUT /api/0/organizations/{organization_id_or_slug}/issues/{issue_id}/
@required {issue_id: str}
@optional {status: str, statusDetails: map{inNextRelease: bool, inRelease: str, inCommit: str}, assignedTo: str, hasSeen: bool, isBookmarked: bool, isSubscribed: bool, isPublic: bool}
@returns(200) {annotations: [str], assignedTo: map?, count: str, culprit: str, firstSeen: str, hasSeen: bool, id: str, isBookmarked: bool, isPublic: bool, isSubscribed: bool, lastSeen: str, level: str, logger: str?, metadata: any, numComments: int, permalink: str, project: map{id: str, name: str, slug: str}, shareId: str?, shortId: str, status: str, statusDetails: map, subscriptionDetails: map?, title: str, type: str, userCount: int}
@errors {403, 404}

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

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

@endpoint POST /api/0/organizations/{organization_id_or_slug}/releases/
@required {version: str, projects: [str]}
@optional {ref: str, url: str, dateReleased: str(date-time), commits: [map{patch_set: [map], repository: str, author_name: str, author_email: str, timestamp: str(date-time), message: str, id: str}], refs: [map{repository: str, commit: str, previousCommit: str}]}
@returns(201) {id: int, authors: [map], commitCount: int(int64), data: map, dateCreated: str(date-time), dateReleased: str(date-time)?, deployCount: int(int64), firstEvent: str(date-time)?, lastCommit: map?, lastDeploy: map?, lastEvent: str(date-time)?, newGroups: int(int64), owner: map?, projects: [map], ref: str?, shortVersion: str, version: str, url: str?}
@errors {400, 403}

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

@endpoint POST /api/0/organizations/{organization_id_or_slug}/releases/{version}/files/
@required {version: str}
@returns(201)
@errors {403, 404}

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

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

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

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

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

@endpoint GET /api/0/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: bool}
@returns(200) {sha1: str, dist: str?, name: str, dateCreated: str(date-time), headers: map{Content-Type: str}, id: str, size: int}
@errors {403, 404}

@endpoint PUT /api/0/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 {name: str, dist: str}
@returns(200) {sha1: str, dist: str?, name: str, dateCreated: str(date-time), headers: map{Content-Type: str}, id: str, size: int}
@errors {403, 404}

@endpoint DELETE /api/0/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 {403, 404}

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

@endpoint GET /api/0/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 {403, 404}

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

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

@endpoint POST /api/0/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 /api/0/sentry-app-installations/{uuid}/external-issues/{external_issue_id}/
@required {uuid: str, external_issue_id: str}
@returns(204)
@errors {403, 404}

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

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

@endpoint GET /api/0/organizations/{organization_id_or_slug}/issues/{issue_id}/autofix/
@required {issue_id: int}
@returns(200) {autofix: map?}
@errors {401, 403, 404}

@endpoint POST /api/0/organizations/{organization_id_or_slug}/issues/{issue_id}/autofix/
@required {issue_id: int}
@optional {event_id: str, instruction: str, pr_to_comment_on_url: str(uri), stopping_point: str(root_cause/solution/code_changes/open_pr)}
@returns(202) {run_id: int}
@errors {400, 401, 403, 404}

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

@endpoint GET /api/0/organizations/{organization_id_or_slug}/issues/{issue_id}/events/{event_id}/
@required {issue_id: int, event_id: str(latest/oldest/recommended)}
@optional {environment: [str]}
@returns(200) {id: str, groupID: str?, eventID: str, projectID: str, message: str?, title: str, location: str?, user: map?{id: str?, email: str?, username: str?, ip_address: str?, name: str?, geo: map?, data: map?}, tags: [map], platform: str, dateReceived: str(date-time)?, contexts: map?, size: int?, entries: [any], dist: str?, sdk: map, context: map?, packages: map, type: str, metadata: any, errors: [any], occurrence: any, _meta: map, crashFile: str?, culprit: str?, dateCreated: str(date-time), fingerprints: [str], groupingConfig: any, startTimestamp: str(date-time), endTimestamp: str(date-time), measurements: any, breakdowns: any, release: map?{id: int, commitCount: int, data: map, dateCreated: str(date-time), dateReleased: str(date-time)?, deployCount: int, ref: str?, lastCommit: map?, lastDeploy: map?{dateStarted: str?, url: str?, id: str, environment: str, dateFinished: str, name: str}, status: str, url: str?, userAgent: str?, version: str?, versionInfo: map?{description: str, package: str?, version: map, buildHash: str?}}, userReport: map?{id: str, eventID: str, name: str?, email: str?, comments: str, dateCreated: str, user: map?{id: str, username: str?, email: str?, name: str?, ipAddress: str?, avatarUrl: str?}, event: map{id: str, eventID: str}}, sdkUpdates: [map], resolvedWith: [str], nextEventID: str?, previousEventID: str?}
@errors {400, 401, 403, 404}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/issues/{issue_id}/external-issues/
@required {issue_id: int}
@returns(200)

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

@end
