@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 220
@hint download_for_search
@toc api(220)

@endpoint GET /api/0/organizations/
@optional {owner: bool, cursor: str, query: str, sortBy: str, per_page: int}
@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, defaultRole: str(member/admin/manager/owner), openMembership: bool, eventsMemberAdmin: bool, alertsMemberWrite: bool, attachmentsRole: str(member/admin/manager/owner), debugFilesRole: str(member/admin/manager/owner), hasGranularReplayPermissions: bool, replayAccessMembers: [int], avatarType: str(letter_avatar/upload), avatar: str, require2FA: bool, allowSharedIssues: bool, enhancedPrivacy: bool, scrapeJavaScript: bool, storeCrashReports: int(0/1/5/10/20/50/100/-1), allowJoinRequests: bool, dataScrubber: bool, dataScrubberDefaults: bool, sensitiveFields: [str], safeFields: [str], scrubIPAddresses: bool, relayPiiConfig: str, trustedRelays: [map], relayDsnEndpoint: str, issueAlertsThreadFlag: bool, metricAlertsThreadFlag: bool, cancelDeletion: bool}
@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?, relayDsnEndpoint: str?, trustedRelays: [map], pendingAccessRequests: int, hideAiFeatures: bool, aggregatedDataConsent: bool, isDynamicallySampled: bool, issueAlertsThreadFlag: bool, metricAlertsThreadFlag: bool, requiresSso: bool, defaultAutofixAutomationTuning: str, defaultSeerScannerAutomation: bool, enableSeerCoding: bool, defaultCodingAgent: str, defaultCodingAgentIntegrationId: str?, defaultAutomatedRunStoppingPoint: str, autoEnableCodeReview: bool, autoOpenPrs: bool, defaultCodeReviewTriggers: [str], teams: [map], projects: [map]}
@errors {400, 401, 403, 404, 409, 413}

@endpoint GET /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, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, widgets: [map], projects: [int], filters: map{release: [str], releaseId: [str], globalFilter: [map]}, permissions: map?{isEditableByEveryone: bool, teamsWithEditAccess: [int]}, isFavorited: bool, prebuiltId: int?}
@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, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, widgets: [map], projects: [int], filters: map{release: [str], releaseId: [str], globalFilter: [map]}, permissions: map?{isEditableByEveryone: bool, teamsWithEditAccess: [int]}, isFavorited: bool, prebuiltId: int?}
@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, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, widgets: [map], projects: [int], filters: map{release: [str], releaseId: [str], globalFilter: [map]}, permissions: map?{isEditableByEveryone: bool, teamsWithEditAccess: [int]}, isFavorited: bool, prebuiltId: int?}
@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: [any], 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: [any], query: str, id: [int]}
@returns(200)
@errors {400, 401, 403, 404}

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

@endpoint GET /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}
@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}
@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, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}}
@errors {400, 403, 404}

@endpoint GET /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, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}}
@errors {403, 404}

@endpoint PUT /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, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}}
@errors {400, 403, 404}

@endpoint DELETE /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: map?{id: str, projectId: int, eventId: str, fingerprint: [str], issueTitle: str, subtitle: str, resourceId: str?, evidenceData: map, evidenceDisplay: [map], type: int, detectionTime: num(double), level: str?, culprit: str?, assignee: str?, priority: int?}, _meta: map, crashFile: str?, culprit: str?, dateCreated: str(date-time), fingerprints: [str], groupingConfig: map{id: str, enhancements: str}, 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(errors/logs/profile_functions/spans/tracemetrics/uptime_results)}
@optional {end: str(date-time), environment: [str], project: [any], start: str(date-time), statsPeriod: str, per_page: int, query: str, sort: str, allowAggregateConditions: bool, cursor: str}
@returns(200) {data: [map], meta: map{fields: map, units: map, tips: map, datasetReason: str, isMetricsData: bool, isMetricsExtractedData: bool, dataset: str, discoverSplitDecision: any, dataScanned: str, bytesScanned: int, debug_info: any}}
@errors {400, 403}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/events-timeseries/
@required {dataset: str(errors/logs/profile_functions/spans/tracemetrics/uptime_results)}
@optional {end: str(date-time), environment: [str], project: [any], start: str(date-time), statsPeriod: str, topEvents: int, comparisonDelta: int, interval: 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: [any], 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/recommended/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: [any], id: [int], query: str=is:unresolved, viewId: str, sort: str(date/freq/inbox/new/recommended/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: [any], id: [int], query: str=is:unresolved, viewId: str, sort: str(date/freq/inbox/new/recommended/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, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, orgRole: str, pending: bool, expired: bool, flags: map{idp:provisioned: bool, idp:role-restricted: bool, sso:linked: bool, sso:invalid: bool, member-limit:restricted: bool, partnership:restricted: bool}, dateCreated: str(date-time), inviteStatus: str, inviterName: str?}
@errors {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, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, orgRole: str, pending: bool, expired: bool, flags: map{idp:provisioned: bool, idp:role-restricted: bool, sso:linked: bool, sso:invalid: bool, member-limit:restricted: bool, partnership:restricted: bool}, dateCreated: str(date-time), inviteStatus: str, inviterName: str?, teams: [str], teamRoles: [map], 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, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, orgRole: str, pending: bool, expired: bool, flags: map{idp:provisioned: bool, idp:role-restricted: bool, sso:linked: bool, sso:invalid: bool, member-limit:restricted: bool, partnership:restricted: bool}, dateCreated: str(date-time), inviteStatus: str, inviterName: str?, teams: [str], teamRoles: [map], 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: [any], 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: [any], project_id_or_slug: [str], triggerType: str}
@returns(201) {id: int, organizationId: int, integrationId: int?, sentryAppId: int?, projects: [int], serviceType: str?, triggerType: str, targetType: str?, targetIdentifier: str?, targetDisplay: str?}
@errors {400, 403}

@endpoint POST /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) {id: int, organizationId: int, integrationId: int?, sentryAppId: int?, projects: [int], serviceType: str?, triggerType: str, targetType: str?, targetIdentifier: str?, targetDisplay: str?}
@errors {400, 403}

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

@endpoint PUT /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) {id: int, organizationId: int, integrationId: int?, sentryAppId: int?, projects: [int], serviceType: str?, triggerType: str, targetType: str?, targetIdentifier: str?, targetDisplay: str?}
@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?, installUrlExpiresAt: 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}/preprodartifacts/snapshots/{snapshot_id}/
@required {snapshot_id: str}
@optional {compact_metadata: str}
@returns(200) {head_artifact_id: str, base_artifact_id: str?, project_id: str, comparison_type: str, state: str, vcs_info: map{head_sha: str?, base_sha: str?, provider: str?, head_repo_name: str?, base_repo_name: str?, head_ref: str?, base_ref: str?, pr_number: int?}, app_id: str?, is_selective: bool, images: [map], image_count: int, added: [map], added_count: int, removed: [map], removed_count: int, renamed: [map], renamed_count: int, changed: [map], changed_count: int, unchanged: [map], unchanged_count: int, errored: [map], errored_count: int, skipped: [map], skipped_count: int, diff_threshold: num(double)?, comparison_state: str?, approval_status: str?, comparison_error_message: str?, approvers: [map]}
@errors {403, 404}

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

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

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

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

@endpoint GET /api/0/organizations/{organization_id_or_slug}/profiling/flamegraph/
@optional {project: [any], environment: [str], statsPeriod: str, start: str(date-time), end: str(date-time), dataSource: str(functions/profiles/spans/transactions), fingerprint: int, query: str, expand: [str]}
@returns(200)
@errors {401, 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, per_page: int, query: str}
@returns(200)
@errors {401, 403, 404}

@endpoint POST /api/0/organizations/{organization_id_or_slug}/projects/
@required {name: str}
@optional {slug: str, platform: str, default_rules: bool}
@returns(201) {latestDeploys: map?, options: map, stats: any, transactionStats: 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, 401, 403, 404, 409}

@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}
@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], project: [any]}
@returns(200)
@errors {400}

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

@endpoint POST /api/0/organizations/{organization_id_or_slug}/releases/
@required {version: str, projects: [any]}
@optional {ref: str, url: str(uri), dateReleased: str(date-time), commits: [map{id!: str, repository: str, message: str, author_name: str, author_email: str, timestamp: str(date-time), patch_set: [map]}], status: str, owner: str, headCommits: [map{currentId!: str, repository!: str, previousId: str}], refs: [map{commit!: str, repository!: str, previousCommit: str}]}
@returns(201) {ref: str?, url: str?, dateReleased: str(date-time)?, dateCreated: str(date-time)?, dateStarted: str(date-time)?, owner: map?, 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: [any], projects: [map]}
@returns(208)
@errors {400, 401, 403}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/releases/{version}/
@required {version: str}
@optional {project_id: str, project: any, health: bool, adoptionStages: bool, summaryStatsPeriod: str(14d/1d/1h/24h/2d/30d/48h/7d/90d), healthStatsPeriod: str(14d/1d/1h/24h/2d/30d/48h/7d/90d), sort: str(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: [any], 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: [any], 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}/commits/
@required {version: str}
@optional {cursor: str}
@returns(200)
@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}/releases/{version}/files/
@required {version: str}
@optional {query: [str], checksum: [str], cursor: str}
@returns(200)
@errors {401, 403, 404}

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

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

@endpoint PUT /api/0/organizations/{organization_id_or_slug}/releases/{version}/files/{file_id}/
@required {version: str, file_id: str, name: str}
@returns(200) {id: str, name: str, dist: str?, headers: map, size: int, sha1: str, dateCreated: str(date-time)}
@errors {400, 401, 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 {401, 403, 404}

@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: [any], project_id_or_slug: [str], query: str, data_source: str(discover/events/search_issues/transactions), returnIds: bool}
@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: [any], projectSlug: [str], sort: str, sortBy: str, orderBy: str, cursor: str, per_page: int, query: str}
@returns(200) {data: [map]}
@errors {400, 403}

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

@endpoint GET /api/0/organizations/{organization_id_or_slug}/replays/{replay_id}/
@required {replay_id: str}
@optional {statsPeriod: str, start: str(date-time), end: str(date-time), field: [str], project: [any], projectSlug: [str], environment: str, sort: str, sortBy: str, orderBy: str, query: str, per_page: int, cursor: str}
@returns(200) {data: map{id: str, project_id: str, trace_ids: [str], error_ids: [str], environment: str?, tags: any, user: map{id: str?, username: str?, email: str?, ip: str?, display_name: str?, geo: map{city: str?, country_code: str?, region: str?, subdivision: str?}}, sdk: map{name: str?, version: str?}, os: map{name: str?, version: str?}, browser: map{name: str?, version: str?}, device: map{name: str?, brand: str?, model: str?, family: str?}, ota_updates: map{channel: str?, runtime_version: str?, update_id: str?}, is_archived: bool?, urls: [str]?, 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/
@optional {query: str, status: str(active/deleted), integration_id: str, expand: [str], cursor: str}
@returns(200)
@errors {401, 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: [any], per_page: int, interval: str, groupBy: [str], orderBy: str, includeTotals: int, includeSeries: int, query: str}
@returns(200) {start: str(date-time), end: str(date-time), intervals: [str], groups: [map], query: str}
@errors {400, 401}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/shortids/{issue_id}/
@required {issue_id: str}
@optional {collapse: [str]}
@returns(200) {organizationSlug: str, projectSlug: str, groupId: str, group: map{isUnhandled: bool, count: str, userCount: int, firstSeen: str(date-time)?, lastSeen: str(date-time)?, 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, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, inNextRelease: bool, inRelease: str, inCommit: str, pendingEvents: int, info: 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}/tags/
@optional {project: [any], environment: [str], statsPeriod: str, start: str(date-time), end: str(date-time), dataset: str(discover/events/replays/search_issues), use_cache: str(0/1), useFlagsBackend: str(0/1)}
@returns(200)
@errors {400, 401, 403}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/teams/
@optional {detailed: str, cursor: str, per_page: int, query: 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}/trace-items/attributes/
@optional {statsPeriod: str, start: str(date-time), end: str(date-time), dataset: str(logs/preprod/processing_errors/spans/tracemetrics), itemType: str(logs/preprod/processing_errors/spans/tracemetrics), attributeType: [str], substringMatch: str, query: str, cursor: str}
@returns(200)
@errors {401, 403, 404}

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

@endpoint GET /api/0/organizations/{organization_id_or_slug}/trace/{trace_id}/
@required {trace_id: str}
@optional {statsPeriod: str, start: str(date-time), end: str(date-time), referrer: str, errorId: str, additional_attributes: [str], include_uptime: str(0/1)}
@returns(200)
@errors {401, 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: [any]}
@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: [map], 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: [any]}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint DELETE /api/0/organizations/{organization_id_or_slug}/workflows/
@optional {query: str, id: [int], project: [any]}
@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: [map], 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}, platforms: [str], processingIssues: int, defaultEnvironment: str?, relayPiiConfig: str?, builtinSymbolSources: [str], dynamicSamplingBiases: [map]?, symbolSources: str, isDynamicallySampled: bool, tempestFetchScreenshots: bool, autofixAutomationTuning: str, seerScannerAutomation: bool, seerNightshiftTweaks: any, 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}, platforms: [str], processingIssues: int, defaultEnvironment: str?, relayPiiConfig: str?, builtinSymbolSources: [str], dynamicSamplingBiases: [map]?, symbolSources: str, isDynamicallySampled: bool, tempestFetchScreenshots: bool, autofixAutomationTuning: str, seerScannerAutomation: bool, seerNightshiftTweaks: any, 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 PUT /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/environments/
@required {project_id_or_slug: str, environmentNames: [str], isHidden: bool}
@returns(200)
@errors {400, 401, 403, 404}

@endpoint GET /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}/
@required {project_id_or_slug: str, event_id: str}
@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: map?{id: str, projectId: int, eventId: str, fingerprint: [str], issueTitle: str, subtitle: str, resourceId: str?, evidenceData: map, evidenceDisplay: [map], type: int, detectionTime: num(double), level: str?, culprit: str?, assignee: str?, priority: int?}, _meta: map, crashFile: str?, culprit: str?, dateCreated: str(date-time), fingerprints: [str], groupingConfig: map{id: str, enhancements: str}, 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 {401, 403, 404}

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

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

@endpoint GET /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}
@returns(200) {dist: str?, release: str?, exceptions: [map], has_debug_ids: bool, min_debug_id_sdk_version: str?, sdk_version: str?, project_has_some_artifact_bundle: bool, release_has_some_artifact: bool, has_uploaded_some_artifact_with_a_debug_id: bool, sdk_debug_id_support: str, has_scraping_data: bool}
@errors {401, 403, 404}

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

@endpoint 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}/preprod/size-analysis/status-check-rules/
@required {project_id_or_slug: str}
@returns(200) {enabled: bool, rules: [map]}
@errors {403, 404}

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

@endpoint 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?, installUrlExpiresAt: 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?, installUrlExpiresAt: str?, downloadCount: int, releaseNotes: str?, installGroups: [str]?, isCodeSignatureValid: bool?, profileName: str?, codesigningType: str?}}
@errors {400, 403}

@endpoint POST /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/preprodartifacts/snapshots/
@required {project_id_or_slug: str}
@returns(200) {artifactId: str, snapshotMetricsId: str, imageCount: int, snapshotUrl: str}
@errors {400, 403}

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

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

@endpoint GET /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 {401, 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 {query: [str], checksum: [str], cursor: str}
@returns(200)
@errors {401, 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) {id: str, name: str, dist: str?, headers: map, size: int, sha1: str, dateCreated: str(date-time)}
@errors {400, 401, 403, 404, 409}

@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: str}
@returns(200) {id: str, name: str, dist: str?, headers: map, size: int, sha1: str, dateCreated: str(date-time)}
@errors {401, 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, name: str}
@returns(200) {id: str, name: str, dist: str?, headers: map, size: int, sha1: str, dateCreated: str(date-time)}
@errors {400, 401, 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 {401, 403, 404}

@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}
@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}
@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}
@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, segment_id: int}
@returns(200) {data: map{replayId: str, segmentId: int, projectId: str, dateAdded: str?}}
@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}
@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 POST /api/0/projects/{organization_id_or_slug}/{project_id_or_slug}/repo/
@required {project_id_or_slug: str, repositoryId: int}
@returns(201) {id: str, projectId: str, repositoryId: str, source: str, created: bool}
@errors {400, 404}

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

@endpoint GET /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/projects/{organization_id_or_slug}/{project_id_or_slug}/users/
@required {project_id_or_slug: str}
@optional {query: str, cursor: str}
@returns(200)
@errors {401, 403, 404}

@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, webhookHeaders: [str], isDisabled: bool, author: str?, overview: str?, popularity: int?, redirectUrl: str?, webhookUrl: str?, clientSecret: str?, datePublished: str(date-time), clientId: str, owner: map{id: int, slug: str}}

@endpoint PUT /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], webhookHeaders: [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, webhookHeaders: [str], isDisabled: bool, author: str?, overview: str?, popularity: int?, redirectUrl: str?, webhookUrl: str?, clientSecret: str?, datePublished: str(date-time), clientId: str, owner: map{id: int, slug: str}}
@errors {400, 403}

@endpoint DELETE /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}
@optional {name: str}
@returns(200) {id: str, slug: str, name: str, dateCreated: str(date-time)?, isMember: bool, teamRole: str?, flags: map, access: [str], hasAccess: bool, isPending: bool, memberCount: int, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, externalTeams: [map], organization: map{features: [str], extraOptions: map, access: [str], onboardingTasks: [map], id: str, slug: str, status: map{id: str, name: str}, name: str, dateCreated: str(date-time), isEarlyAdopter: bool, require2FA: bool, avatar: map{avatarType: str, avatarUuid: str?, avatarUrl: str?}, links: map{organizationUrl: str, regionUrl: str}, hasAuthProvider: bool, allowMemberInvite: bool, allowMemberProjectCreation: bool, allowSuperuserAccess: bool}, projects: [map]}
@errors {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/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}/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}/issues/
@required {project_id_or_slug: str}
@optional {statsPeriod: str, shortIdLookup: bool, query: str, hashes: str, sort: str(date/new/trends/freq/user/inbox)=date, limit: int=100, 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: str, 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}/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}/
@required {issue_id: str}
@optional {environment: [str], expand: [str], collapse: [str]}
@returns(200) {isUnhandled: bool, count: str, userCount: int, firstSeen: str(date-time)?, lastSeen: str(date-time)?, 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{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [any], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, inNextRelease: bool, inRelease: str, inCommit: str, pendingEvents: int, info: 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], firstRelease: map?, lastRelease: map?, tags: [map], stats: map, inbox: map?{reason: int, reason_details: map?{until: str?, count: int?, window: int?, user_count: int?, user_window: int?}, date_added: str(date-time)}, owners: [map]?, forecast: map, integrationIssues: [map], sentryAppIssues: [map], latestEventHasAttachments: bool, activity: [map], seenBy: [map], userReportCount: int, participants: [map]}
@errors {401, 403, 404}

@endpoint PUT /api/0/organizations/{organization_id_or_slug}/issues/{issue_id}/
@required {issue_id: str, 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)}
@returns(200) {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{avatarType: str, avatarUuid: str?, avatarUrl: str?}, authenticators: [any], canReset2fa: bool, id: str, name: str, username: str, email: str, avatarUrl: str, isActive: bool, isSuspended: bool, hasPasswordAuth: bool, isManaged: bool, dateJoined: str(date-time), lastLogin: str(date-time)?, has2fa: bool, lastActive: str(date-time)?, isSuperuser: bool, isStaff: bool, experiments: map, emails: [map]}, inNextRelease: bool, inRelease: str, inCommit: str, pendingEvents: int, info: 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]}
@errors {400, 401, 403, 404}

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

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

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

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

@endpoint GET /api/0/organizations/{organization_id_or_slug}/issues/{issue_id}/events/{event_id}/
@required {issue_id: str, 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: map?{id: str, projectId: int, eventId: str, fingerprint: [str], issueTitle: str, subtitle: str, resourceId: str?, evidenceData: map, evidenceDisplay: [map], type: int, detectionTime: num(double), level: str?, culprit: str?, assignee: str?, priority: int?}, _meta: map, crashFile: str?, culprit: str?, dateCreated: str(date-time), fingerprints: [str], groupingConfig: map{id: str, enhancements: str}, 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: str}
@returns(200)

@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 {401, 403, 404}

@endpoint GET /api/0/organizations/{organization_id_or_slug}/issues/{issue_id}/integrations/{integration_id}/
@required {issue_id: str, integration_id: str, action: str(create/link)}
@returns(200) {id: str, name: str, icon: str?, domainName: str?, accountType: str?, scopes: [str]?, status: str, provider: map{key: str, slug: str, name: str, canAdd: bool, canDisable: bool, features: [str], aspects: map}, linkIssueConfig: [map], createIssueConfig: [map]}
@errors {400, 401, 403, 404}

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

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

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

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

@end
