@sentry/api 0.444.0 → 0.446.0

package/dist/api-client/endpoints/monitors.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Cron monitor endpoints. With a project, reads go to the project's
+ * endpoints, otherwise to the organization's. Each wrapper validates the
+ * response with the schema the host passes, so the host's schema decides the
+ * result type.
+ */
+import { type ApiTarget, type ResponseSchema } from "@sentry/api/client";
+export type ListMonitorsParams = {
+    organizationSlug: string;
+    projectSlug?: string;
+    environment?: string;
+    owner?: string;
+    query?: string;
+    /** Page size. */
+    limit?: number;
+};
+/** The first page of the organization's cron monitors. */
+export declare function listMonitors<T>({ core, origin }: ApiTarget, { organizationSlug, projectSlug, environment, owner, query, limit, }: ListMonitorsParams, schema: ResponseSchema<T>): Promise<T>;
+export type MonitorParams = {
+    organizationSlug: string;
+    projectSlug?: string;
+    monitorSlug: string;
+    environment?: string;
+};
+/** One cron monitor. */
+export declare function getMonitor<T>({ core, origin }: ApiTarget, params: MonitorParams, schema: ResponseSchema<T>): Promise<T>;
+/**
+ * Schedule deletion of one environment of a cron monitor. Sentry answers 202
+ * with no body; a 404 (already gone) is not an error.
+ */
+export declare function deleteMonitorEnvironment({ core, origin }: ApiTarget, { organizationSlug, projectSlug, monitorSlug, environment, }: MonitorParams & {
+    projectSlug: string;
+    environment: string;
+}): Promise<void>;
+export type MonitorTimeRangeParams = MonitorParams & {
+    /** Relative range such as `24h`. Default: `24h` without `start` or `end`. */
+    statsPeriod?: string;
+    start?: string;
+    end?: string;
+};
+/** The first page of a cron monitor's check-ins in a time range. */
+export declare function listMonitorCheckIns<T>({ core, origin }: ApiTarget, params: MonitorTimeRangeParams & {
+    limit?: number;
+}, schema: ResponseSchema<T>): Promise<T>;
+/** A cron monitor's check-in counts over a time range. */
+export declare function getMonitorStats<T>({ core, origin }: ApiTarget, params: MonitorTimeRangeParams & {
+    /** Bucket size in seconds. */
+    rollup?: number;
+}, schema: ResponseSchema<T>): Promise<T>;

package/dist/api-client/endpoints/organizations.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Organization and current-user endpoints. Each wrapper validates the
+ * response with the schema the host passes, so the host's schema decides the
+ * result type. Hosts pick the origin: user identity and the organization
+ * list live on the control host, an organization on its region.
+ */
+import { type ApiTarget, type ListPage, type ResponseSchema } from "@sentry/api/client";
+/** The user the request's credential belongs to (`GET /auth/`). */
+export declare function getAuthenticatedUser<T>({ core, origin }: ApiTarget, schema: ResponseSchema<T>): Promise<T>;
+export type ListOrganizationsParams = {
+    /** Filters by name or slug. */
+    query?: string;
+    /** Most organizations to return. Default: 25. */
+    limit?: number;
+    /** Resumes from a previous call's `nextCursor`. */
+    cursor?: string | null;
+};
+/** A page of the organizations the credential can access. */
+export declare function listOrganizations<T>({ core, origin }: ApiTarget, params: ListOrganizationsParams, schema: ResponseSchema<T[]>): Promise<ListPage<T>>;
+export type GetOrganizationParams = {
+    organizationSlug: string;
+    /** Include `features`, which Sentry omits otherwise. */
+    includeFeatureFlags?: boolean;
+    /** Set false to leave out projects and teams; Sentry defaults to true. */
+    detailed?: boolean;
+};
+/** One organization by slug. */
+export declare function getOrganization<T>({ core, origin }: ApiTarget, params: GetOrganizationParams, schema: ResponseSchema<T>): Promise<T>;
+export type UpdateAgenticOnboardingStatusParams = {
+    organizationSlug: string;
+    /** The status report, sent as the JSON body. */
+    update: object;
+};
+/** Report progress of an agent-driven onboarding run. */
+export declare function updateAgenticOnboardingStatus<T>({ core, origin }: ApiTarget, { organizationSlug, update }: UpdateAgenticOnboardingStatusParams, schema: ResponseSchema<T>): Promise<T>;

package/dist/api-client/endpoints/profiling.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Profiling endpoints. Each wrapper validates the response with the schema
+ * the host passes, so the host's schema decides the result type.
+ */
+import { type ApiTarget, type ResponseSchema } from "@sentry/api/client";
+export type GetFlamegraphParams = {
+    organizationSlug: string;
+    projectId: string | number;
+    /** Matched exactly; quotes and backslashes are escaped. */
+    transactionName: string;
+    /** Default: `7d`. */
+    statsPeriod?: string;
+};
+/** The aggregated flamegraph of a transaction's profiles. */
+export declare function getFlamegraph<T>({ core, origin }: ApiTarget, { organizationSlug, projectId, transactionName, statsPeriod, }: GetFlamegraphParams, schema: ResponseSchema<T>): Promise<T>;
+/** One transaction profile. */
+export declare function getTransactionProfile<T>({ core, origin }: ApiTarget, { organizationSlug, projectSlugOrId, profileId, }: {
+    organizationSlug: string;
+    projectSlugOrId: string | number;
+    profileId: string;
+}, schema: ResponseSchema<T>): Promise<T>;
+export type GetProfileChunksParams = {
+    organizationSlug: string;
+    profilerId: string;
+    projectId: string | number;
+    /** ISO timestamp. */
+    start: string;
+    /** ISO timestamp. */
+    end: string;
+};
+/** The continuous profile chunks of a profiler in a time range. */
+export declare function getProfileChunks<T>({ core, origin }: ApiTarget, { organizationSlug, profilerId, projectId, start, end, }: GetProfileChunksParams, schema: ResponseSchema<T>): Promise<T>;

package/dist/api-client/endpoints/projects.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Project endpoints: listing, reading, creating, and updating projects, and
+ * the teams assigned to a project. Each wrapper validates the response with
+ * the schema the host passes, so the host's schema decides the result type.
+ */
+import { type ApiTarget, type ListPage, type ResponseSchema } from "@sentry/api/client";
+export type ListProjectsParams = {
+    organizationSlug: string;
+    /** Filters by name or slug. */
+    query?: string;
+    /** Most projects to return. Default: 25. */
+    limit?: number;
+    /** Resumes from a previous call's `nextCursor`. */
+    cursor?: string | null;
+};
+/** A page of the organization's projects. */
+export declare function listProjects<T>({ core, origin }: ApiTarget, params: ListProjectsParams, schema: ResponseSchema<T[]>): Promise<ListPage<T>>;
+export type GetProjectParams = {
+    organizationSlug: string;
+    projectSlugOrId: string;
+    /** Return only the organization's ID and slug instead of all of it. */
+    collapse?: "organization";
+};
+/** One project by slug or ID. */
+export declare function getProject<T>({ core, origin }: ApiTarget, { organizationSlug, projectSlugOrId, collapse }: GetProjectParams, schema: ResponseSchema<T>): Promise<T>;
+export type CreateProjectParams = {
+    organizationSlug: string;
+    /** The team that owns the new project. */
+    teamSlug: string;
+    name: string;
+    slug?: string | null;
+    platform?: string | null;
+};
+/** Create a project owned by a team. Empty `slug` and `platform` are left out. */
+export declare function createProject<T>({ core, origin }: ApiTarget, { organizationSlug, teamSlug, name, slug, platform }: CreateProjectParams, schema: ResponseSchema<T>): Promise<T>;
+export type UpdateProjectParams = {
+    organizationSlug: string;
+    projectSlug: string;
+    name?: string | null;
+    slug?: string | null;
+    platform?: string | null;
+};
+/** Update a project. Only non-empty fields are sent. */
+export declare function updateProject<T>({ core, origin }: ApiTarget, { organizationSlug, projectSlug, name, slug, platform }: UpdateProjectParams, schema: ResponseSchema<T>): Promise<T>;
+export type ProjectTeamParams = {
+    organizationSlug: string;
+    projectSlug: string;
+};
+/**
+ * Every team assigned to a project, across all pages.
+ *
+ * @throws {Error} When a cursor repeats or the walk passes
+ *   {@link MAX_LIST_PAGES}
+ */
+export declare function listProjectTeams<T>({ core, origin }: ApiTarget, { organizationSlug, projectSlug }: ProjectTeamParams, schema: ResponseSchema<T[]>): Promise<T[]>;
+/** Assign a team to a project. */
+export declare function addProjectTeam({ core, origin }: ApiTarget, { organizationSlug, projectSlug, teamSlug, }: ProjectTeamParams & {
+    teamSlug: string;
+}): Promise<void>;
+/** Remove a team from a project. */
+export declare function removeProjectTeam({ core, origin }: ApiTarget, { organizationSlug, projectSlug, teamSlug, }: ProjectTeamParams & {
+    teamSlug: string;
+}): Promise<void>;

package/dist/api-client/endpoints/releases.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Release endpoints: releases, their deploys and commits, and an event's
+ * suspect committers. With a project, release reads go to the project's
+ * endpoints, otherwise to the organization's. Each wrapper validates the
+ * response with the schema the host passes, so the host's schema decides the
+ * result type.
+ */
+import { type ApiTarget, type ResponseSchema } from "@sentry/api/client";
+export type ListReleasesParams = {
+    organizationSlug: string;
+    projectSlug?: string;
+    /** Filters by version. */
+    query?: string;
+    /** Page size. */
+    limit?: number;
+};
+/** The first page of releases for the organization or one project. */
+export declare function listReleases<T>({ core, origin }: ApiTarget, { organizationSlug, projectSlug, query, limit }: ListReleasesParams, schema: ResponseSchema<T>): Promise<T>;
+export type ReleaseParams = {
+    organizationSlug: string;
+    releaseVersion: string;
+    projectSlugOrId?: string;
+};
+/** One release, optionally with its health data. */
+export declare function getRelease<T>({ core, origin }: ApiTarget, { organizationSlug, releaseVersion, projectSlugOrId, includeHealth, }: ReleaseParams & {
+    includeHealth?: boolean;
+}, schema: ResponseSchema<T>): Promise<T>;
+/**
+ * The first page of a release's deploys. A project narrows them, by ID when
+ * it is numeric and by slug otherwise.
+ */
+export declare function listReleaseDeploys<T>({ core, origin }: ApiTarget, { organizationSlug, releaseVersion, projectSlugOrId, limit, }: ReleaseParams & {
+    limit?: number;
+}, schema: ResponseSchema<T>): Promise<T>;
+/** The first page of a release's commits. */
+export declare function listReleaseCommits<T>({ core, origin }: ApiTarget, { organizationSlug, releaseVersion, projectSlugOrId, limit, }: ReleaseParams & {
+    limit?: number;
+}, schema: ResponseSchema<T>): Promise<T>;
+export type GetEventCommittersParams = {
+    organizationSlug: string;
+    projectSlug: string;
+    eventId: string;
+};
+/** The suspect commits of an event's issue, grouped by committer. */
+export declare function getEventCommitters<T>({ core, origin }: ApiTarget, { organizationSlug, projectSlug, eventId }: GetEventCommittersParams, schema: ResponseSchema<T>): Promise<T>;

package/dist/api-client/endpoints/replays.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Session replay endpoints. Each wrapper validates the response with the
+ * schema the host passes, so the host's schema decides the result type.
+ */
+import { type ApiTarget, type ResponseSchema } from "@sentry/api/client";
+export type SearchReplaysParams = {
+    organizationSlug: string;
+    query?: string;
+    /** Page size. */
+    limit?: number;
+    /** Numeric project ID. */
+    projectId?: string;
+    sort?: string;
+    environment?: string | string[];
+    statsPeriod?: string;
+    start?: string;
+    end?: string;
+    /** Fields to return. */
+    fields?: string[];
+};
+/** The first page of the organization's replays, in the `{ data }` envelope. */
+export declare function searchReplays<T>({ core, origin }: ApiTarget, { organizationSlug, query, limit, projectId, sort, environment, statsPeriod, start, end, fields, }: SearchReplaysParams, schema: ResponseSchema<T>): Promise<T>;
+/** One replay, in the `{ data }` envelope. */
+export declare function getReplay<T>({ core, origin }: ApiTarget, { organizationSlug, replayId, }: {
+    organizationSlug: string;
+    replayId: string;
+}, schema: ResponseSchema<T>): Promise<T>;
+export type IssueReplayIdsParams = {
+    organizationSlug: string;
+    issueId: string | number;
+    dataSource: "discover" | "search_issues";
+};
+/**
+ * The IDs of an issue's replays in the last 90 days, across all projects,
+ * keyed by issue ID.
+ */
+export declare function listIssueReplayIds<T>({ core, origin }: ApiTarget, { organizationSlug, issueId, dataSource }: IssueReplayIdsParams, schema: ResponseSchema<T>): Promise<T>;
+export type ReplayRecordingSegmentsParams = {
+    organizationSlug: string;
+    projectSlugOrId: string;
+    replayId: string;
+    /** Most segments to visit. */
+    maxSegments: number;
+};
+/**
+ * Visit a replay's recording segments page by page, following the `Link`
+ * cursor. Segments go to `onSegment` as each page arrives instead of being
+ * collected, because full DOM snapshots make raw pages large.
+ */
+export declare function visitReplayRecordingSegments<T>({ core, origin }: ApiTarget, { organizationSlug, projectSlugOrId, replayId, maxSegments, }: ReplayRecordingSegmentsParams, pageSchema: ResponseSchema<T[]>, onSegment: (segment: T) => void): Promise<{
+    segmentsRead: number;
+    truncated: boolean;
+}>;

package/dist/api-client/endpoints/repositories.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Repository endpoints: the organization's connected repositories and
+ * linking one to a project with a code mapping. Each wrapper validates the
+ * response with the schema the host passes, so the host's schema decides the
+ * result type.
+ */
+import { type ApiTarget, type ResponseSchema } from "@sentry/api/client";
+export type ListRepositoriesParams = {
+    organizationSlug: string;
+    /** Filters by repository name. */
+    query?: string;
+};
+/**
+ * Every repository connected to the organization, across all pages.
+ *
+ * @throws {Error} When a cursor repeats or the walk passes
+ *   {@link MAX_LIST_PAGES}
+ */
+export declare function listRepositories<T>({ core, origin }: ApiTarget, { organizationSlug, query }: ListRepositoriesParams, schema: ResponseSchema<T[]>): Promise<T[]>;
+export type LinkProjectRepositoryParams = {
+    organizationSlug: string;
+    projectSlug: string;
+    /** The repository's full name, such as `getsentry/sentry`. */
+    repository: string;
+    provider?: string | null;
+};
+/**
+ * Link a repository to a project with one code mapping whose stack and
+ * source roots are both the repository root.
+ */
+export declare function linkProjectRepository<T>({ core, origin }: ApiTarget, { organizationSlug, projectSlug, repository, provider, }: LinkProjectRepositoryParams, schema: ResponseSchema<T>): Promise<T>;

package/dist/api-client/endpoints/snapshots.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Preprod snapshot endpoints. The responses are returned unvalidated: the
+ * callers read them as unknown JSON.
+ */
+import { type ApiTarget } from "@sentry/api/client";
+/** One snapshot, with compact image metadata unless `compactMetadata` is false. */
+export declare function getSnapshot({ core, origin }: ApiTarget, { organizationSlug, snapshotId, compactMetadata, }: {
+    organizationSlug: string;
+    snapshotId: string;
+    compactMetadata?: boolean;
+}): Promise<unknown>;
+/** One image of a snapshot. */
+export declare function getSnapshotImage({ core, origin }: ApiTarget, { organizationSlug, snapshotId, imageIdentifier, }: {
+    organizationSlug: string;
+    snapshotId: string;
+    imageIdentifier: string;
+}): Promise<unknown>;
+export type GetLatestBaseSnapshotParams = {
+    organizationSlug: string;
+    appId: string;
+    branch?: string;
+    /** Numeric project ID. */
+    project?: string;
+    projectSlug?: string;
+    /** Default: true. */
+    compactMetadata?: boolean;
+};
+/** The latest base snapshot of an app, optionally on one branch. */
+export declare function getLatestBaseSnapshot({ core, origin }: ApiTarget, { organizationSlug, appId, branch, project, projectSlug, compactMetadata, }: GetLatestBaseSnapshotParams): Promise<unknown>;

package/dist/api-client/endpoints/teams.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Team endpoints within an organization. Each wrapper validates the response
+ * with the schema the host passes, so the host's schema decides the result
+ * type.
+ */
+import { type ApiTarget, type ListPage, type ResponseSchema } from "@sentry/api/client";
+export type ListTeamsParams = {
+    organizationSlug: string;
+    /** Filters by name or slug. */
+    query?: string;
+    /** Most teams to return. Default: 25. */
+    limit?: number;
+    /** Resumes from a previous call's `nextCursor`. */
+    cursor?: string | null;
+};
+/** A page of the organization's teams. */
+export declare function listTeams<T>({ core, origin }: ApiTarget, params: ListTeamsParams, schema: ResponseSchema<T[]>): Promise<ListPage<T>>;
+export type CreateTeamParams = {
+    organizationSlug: string;
+    name: string;
+};
+/** Create a team in the organization. */
+export declare function createTeam<T>({ core, origin }: ApiTarget, { organizationSlug, name }: CreateTeamParams, schema: ResponseSchema<T>): Promise<T>;

package/dist/api-client/endpoints/traces.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Trace endpoints. Each wrapper validates the response with the schema the
+ * host passes, so the host's schema decides the result type.
+ */
+import { type ApiTarget, type ResponseSchema } from "@sentry/api/client";
+export type TraceParams = {
+    organizationSlug: string;
+    /** 32-character hex trace ID. */
+    traceId: string;
+    /** Default: `14d`. */
+    statsPeriod?: string;
+};
+/** Span, error, and operation counts for a trace. */
+export declare function getTraceMeta<T>({ core, origin }: ApiTarget, { organizationSlug, traceId, statsPeriod }: TraceParams, schema: ResponseSchema<T>): Promise<T>;
+/**
+ * The trace's span tree. `limit` and `project` are the endpoint's declared
+ * parameters; the server currently ignores `project` and paginates
+ * internally, but they are still sent.
+ */
+export declare function getTrace<T>({ core, origin }: ApiTarget, { organizationSlug, traceId, limit, project, statsPeriod, }: TraceParams & {
+    /** Span-count hint. Default: 1000. */
+    limit?: number;
+    /** Project filter hint. Default: `-1` (all projects). */
+    project?: string;
+}, schema: ResponseSchema<T>): Promise<T>;

package/dist/api-client/endpoints/uptime-monitors.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Uptime monitor endpoints. Each wrapper validates the response with the
+ * schema the host passes, so the host's schema decides the result type.
+ */
+import { type ApiTarget, type ResponseSchema } from "@sentry/api/client";
+export type ListUptimeMonitorsParams = {
+    organizationSlug: string;
+    /** Numeric project ID; the endpoint filters by ID, not slug. */
+    projectId?: string;
+    environment?: string;
+    owner?: string;
+    query?: string;
+    /** Page size. */
+    limit?: number;
+};
+/** The first page of the organization's uptime monitors. */
+export declare function listUptimeMonitors<T>({ core, origin }: ApiTarget, { organizationSlug, projectId, environment, owner, query, limit, }: ListUptimeMonitorsParams, schema: ResponseSchema<T>): Promise<T>;
+export type UptimeMonitorParams = {
+    organizationSlug: string;
+    projectSlug: string;
+    uptimeMonitorId: string;
+};
+/** One uptime monitor. */
+export declare function getUptimeMonitor<T>({ core, origin }: ApiTarget, params: UptimeMonitorParams, schema: ResponseSchema<T>): Promise<T>;
+/** The first page of a monitor's checks in a time range, 24 hours by default. */
+export declare function listUptimeMonitorChecks<T>({ core, origin }: ApiTarget, params: UptimeMonitorParams & {
+    statsPeriod?: string;
+    start?: string;
+    end?: string;
+    limit?: number;
+}, schema: ResponseSchema<T>): Promise<T>;
+/** The writable fields of an uptime monitor, in the order they are sent. */
+export type UptimeMonitorFields = {
+    name?: string;
+    url?: string;
+    intervalSeconds?: number;
+    timeoutMs?: number;
+    method?: string;
+    headers?: Array<[string, string]>;
+    body?: string | null;
+    assertion?: unknown;
+    status?: "active" | "disabled";
+    owner?: string | null;
+    environment?: string | null;
+    traceSampling?: boolean;
+    responseCaptureEnabled?: boolean;
+    recoveryThreshold?: number;
+    downtimeThreshold?: number;
+};
+/** Create an uptime monitor in a project. */
+export declare function createUptimeMonitor<T>({ core, origin }: ApiTarget, { organizationSlug, projectSlug, ...fields }: {
+    organizationSlug: string;
+    projectSlug: string;
+} & UptimeMonitorFields & Required<Pick<UptimeMonitorFields, "name" | "url" | "intervalSeconds" | "timeoutMs">>, schema: ResponseSchema<T>): Promise<T>;
+/** Update an uptime monitor. Only the fields that are set are sent. */
+export declare function updateUptimeMonitor<T>({ core, origin }: ApiTarget, { organizationSlug, projectSlug, uptimeMonitorId, ...fields }: UptimeMonitorParams & UptimeMonitorFields, schema: ResponseSchema<T>): Promise<T>;
+/**
+ * Delete an uptime monitor. Sentry answers 202 with no body; a 404 (already
+ * gone) is not an error, so repeated deletes succeed.
+ */
+export declare function deleteUptimeMonitor({ core, origin }: ApiTarget, params: UptimeMonitorParams): Promise<void>;

package/dist/api-client/errors.d.ts

@@ -0,0 +1,151 @@
+import { SentryApiError } from "@sentry/api";
+/**
+ * Error thrown when user input validation fails.
+ * These errors should be returned to the user directly without logging to Sentry.
+ */
+export declare class UserInputError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Error thrown when configuration is invalid or missing.
+ * These errors should be returned to the user directly without logging to Sentry.
+ * Typically used for environment configuration issues, connection settings, etc.
+ */
+export declare class ConfigurationError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * API Error Class Hierarchy
+ *
+ * This module defines a hierarchical error system for the Sentry API client
+ * that automatically categorizes errors based on HTTP status codes.
+ *
+ * Key principles:
+ * - Every class extends `SentryApiError`, the error the generated operations
+ *   return, so `instanceof SentryApiError` matches API failures from both the
+ *   operations and the request core
+ * - 4xx errors (ApiClientError) are user input errors, not reported to Sentry
+ * - 5xx errors (ApiServerError) are system errors, reported to Sentry
+ * - Specific error types provide additional context and helper methods
+ * - The hierarchy enables type-safe error handling without manual status checks
+ */
+/**
+ * Base class for the request core's API errors.
+ * Contains common properties for all API error types.
+ * Status is optional since some errors (like client-side validation) don't have HTTP status codes.
+ * `body` is the parsed response body, the same value as `responseBody`;
+ * `response` is not kept, since the core has consumed it.
+ */
+export declare class ApiError extends SentryApiError<number | undefined, unknown, false> {
+    readonly detail?: string | undefined;
+    readonly responseBody?: unknown | undefined;
+    constructor(message: string, status?: number, detail?: string | undefined, responseBody?: unknown | undefined);
+}
+/**
+ * Client errors (4xx) - User input errors that should NOT be reported to Sentry.
+ * These typically indicate issues with the request that the user can fix.
+ * Also includes client-side validation errors that don't have HTTP status codes.
+ */
+export declare class ApiClientError extends ApiError {
+    constructor(message: string, status?: number, detail?: string, responseBody?: unknown);
+    /**
+     * Convert to a user-friendly formatted message.
+     * Returns the standard format: "API error (status): message" or just "API error: message" if no status.
+     * For 404 errors, adds helpful context about checking parameters.
+     */
+    toUserMessage(): string;
+    /**
+     * Check if this is a permission/authorization error (403)
+     */
+    isPermissionError(): boolean;
+    /**
+     * Check if this is a not found error (404)
+     */
+    isNotFoundError(): boolean;
+    /**
+     * Check if this is a validation error (400 or 422)
+     */
+    isValidationError(): boolean;
+    /**
+     * Check if this is an authentication error (401)
+     */
+    isAuthenticationError(): boolean;
+    /**
+     * Check if this is a rate limit error (429)
+     */
+    isRateLimitError(): boolean;
+}
+/**
+ * Permission denied error (403).
+ * Includes special handling for multi-project access errors.
+ */
+export declare class ApiPermissionError extends ApiClientError {
+    constructor(message: string, detail?: string, responseBody?: unknown);
+    /**
+     * Check if this is the specific multi-project access error
+     */
+    isMultiProjectAccessError(): boolean;
+}
+/**
+ * Resource not found error (404).
+ * Can include additional context about what resource was not found.
+ */
+export declare class ApiNotFoundError extends ApiClientError {
+    readonly resourceType?: string | undefined;
+    readonly resourceId?: string | undefined;
+    constructor(message: string, detail?: string, responseBody?: unknown, resourceType?: string | undefined, resourceId?: string | undefined);
+}
+/**
+ * Validation error (400 or 422 for API responses, or no status for client-side validation).
+ * Indicates the request was malformed or contained invalid data.
+ */
+export declare class ApiValidationError extends ApiClientError {
+    readonly validationErrors?: Record<string, string[]> | undefined;
+    constructor(message: string, status?: 400 | 422, detail?: string, responseBody?: unknown, validationErrors?: Record<string, string[]> | undefined);
+}
+/**
+ * Authentication error (401).
+ * Indicates the request lacks valid authentication credentials.
+ */
+export declare class ApiAuthenticationError extends ApiClientError {
+    constructor(message: string, detail?: string, responseBody?: unknown);
+}
+/**
+ * Rate limit error (429).
+ * `retryAfterMs` comes from the response's `Retry-After` or
+ * `X-Sentry-Rate-Limit-Reset` header, when it has one.
+ */
+export declare class ApiRateLimitError extends ApiClientError {
+    readonly retryAfterMs?: number | undefined;
+    constructor(message: string, detail?: string, responseBody?: unknown, retryAfterMs?: number | undefined);
+    toUserMessage(): string;
+}
+/**
+ * Server errors (5xx) - System errors that SHOULD be reported to Sentry.
+ * These indicate problems with the server that are not the user's fault.
+ */
+export declare class ApiServerError extends ApiError {
+    constructor(message: string, status: number, detail?: string, responseBody?: unknown);
+    /**
+     * Check if this is a gateway/proxy error (502, 503, 504)
+     */
+    isGatewayError(): boolean;
+    /**
+     * Check if this is an internal server error (500)
+     */
+    isInternalError(): boolean;
+}
+/**
+ * Factory function to create the appropriate error type based on HTTP status code.
+ * This centralizes the logic for determining which error class to instantiate.
+ * This is only used for actual API responses, so status is required.
+ */
+export declare function createApiError(message: string, status: number, detail?: string, responseBody?: unknown, retryAfterMs?: number): ApiError;
+/**
+ * Returns true if `error` is an `ApiAuthenticationError`, either directly or
+ * anywhere within the first few levels of `error.cause`. Tools that wrap
+ * upstream errors as `throw new Error(msg, { cause: apiError })` would
+ * otherwise hide the 401 signal from a direct `instanceof` check. Bounded
+ * depth guards against accidental cycles.
+ */
+export declare function isApiAuthenticationErrorDeep(error: unknown): boolean;

package/dist/api-client/idempotent-operations.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Matching for the writes Sentry declares safe to replay, for the transport's
+ * `isIdempotent`. `@sentry/api` marks them `idempotent` from Sentry's
+ * `x-sentry-idempotent` OpenAPI extension, so no product hard-codes which
+ * writes may retry. Each product chooses how it loads the catalog: the CLI
+ * extracts the list at build time to keep startup fast, and MCP reads
+ * `@sentry/api/operations` directly.
+ */
+/** A non-safe operation Sentry marks idempotent. */
+export type IdempotentOperation = {
+    /** Uppercase HTTP method */
+    method: string;
+    /** OpenAPI path template, such as `/api/0/organizations/{org}/chunk-upload/` */
+    path: string;
+};
+/**
+ * The writes in a catalog that Sentry marks idempotent, sorted by path then
+ * method. Safe methods already retry, so they are left out to keep the list
+ * every request checks small.
+ */
+export declare function selectIdempotentWrites(operations: readonly {
+    method: string;
+    path: string;
+    idempotent: boolean;
+}[]): IdempotentOperation[];
+/**
+ * Build `isIdempotent(method, url)` for a list of writes. The list is read on
+ * the first call, so a caller may pass a thunk that loads it lazily.
+ *
+ * Matches from the `/api/` segment on, so a self-hosted install served under
+ * a path prefix still matches.
+ */
+export declare function createIdempotentOperationMatcher(operations: () => readonly IdempotentOperation[]): (method: string, url: string) => boolean;

package/dist/api-client/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `@sentry/api/client`: the request layer the generated operations and
+ * hand-written endpoint wrappers share. It uses only web-standard APIs, so it
+ * runs in Node, Cloudflare Workers, and browsers. Hosts inject what differs
+ * between them: credentials, cache storage, the fresh-read scope, logging,
+ * and spans.
+ */
+export * from "./api-path.js";
+export * from "./auth-token.js";
+export * from "./core.js";
+export * from "./errors.js";
+export * from "./idempotent-operations.js";
+export * from "./pagination.js";
+export * from "./response.js";
+export * from "./response-cache/index.js";
+export * from "./retry.js";
+export type { StandardSchemaV1 } from "./standard-schema.js";
+export * from "./time-params.js";
+export * from "./transport.js";
+export * from "./validate.js";