@rustrak/client 0.18.1 → 0.19.1

package/dist/generated/zod.gen.cjs

@@ -0,0 +1,3273 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let zod = require("zod");
+zod = require_runtime.__toESM(zod, 1);
+//#region src/generated/zod.gen.ts
+const zAcceptInvitation = zod.object({
+	password: zod.string(),
+	token: zod.string()
+});
+/**
+* An entry in an issue's activity log. Comments are stored as activity rows of
+* type `note` with `{"text": ...}` in `data` (Sentry models notes as activity).
+*/
+const zActivityEntry = zod.object({
+	created_at: zod.iso.datetime({ offset: true }),
+	data: zod.string(),
+	id: zod.uuid(),
+	issue_id: zod.uuid(),
+	type: zod.string(),
+	user_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable()
+});
+/**
+* avg/p95 duration for one time bucket.
+*/
+const zAgentDurationPoint = zod.object({
+	avg_ms: zod.number(),
+	bucket: zod.iso.datetime({ offset: true }),
+	p95_ms: zod.number()
+});
+/**
+* One row of the Models table: per response model, the volume, the failures,
+* the latency and the full token split.
+*
+* Cached input and reasoning output are SUBSETS of input/output, not
+* additions — a reader comparing them must not add all four together.
+*/
+const zAgentModelRow = zod.object({
+	avg_ms: zod.number(),
+	cached_input_tokens: zod.number(),
+	errors: zod.int(),
+	input_tokens: zod.number(),
+	model: zod.string(),
+	output_tokens: zod.number(),
+	p95_ms: zod.number(),
+	reasoning_output_tokens: zod.number(),
+	requests: zod.int(),
+	total_tokens: zod.number()
+});
+/**
+* Headline numbers for the agents dashboard, over the selected window.
+*
+* Token totals exclude `agent`-type spans throughout, for the same reason
+* the Traces table does: an agent span's usage is a client-side rollup of
+* its `ai_client` children, so counting both double-counts.
+*/
+const zAgentSummary = zod.object({
+	agent_runs: zod.int(),
+	avg_duration_ms: zod.number(),
+	error_count: zod.int(),
+	llm_calls: zod.int(),
+	p95_duration_ms: zod.number(),
+	tool_calls: zod.int(),
+	total_tokens: zod.number()
+});
+/**
+* One time-bucketed value (count or sum) — mirrors `SessionTimeseriesPoint`.
+*/
+const zAgentTimeseriesPoint = zod.object({
+	bucket: zod.iso.datetime({ offset: true }),
+	value: zod.number()
+});
+/**
+* One row of the Tools table: per tool, how often it ran and how often it
+* failed. A tool with a high failure rate is the most actionable signal the
+* agents page can carry.
+*/
+const zAgentToolRow = zod.object({
+	avg_ms: zod.number(),
+	calls: zod.int(),
+	errors: zod.int(),
+	p95_ms: zod.number(),
+	tool: zod.string()
+});
+zod.object({
+	agent_names: zod.array(zod.string()),
+	duration_ms: zod.number().nullable(),
+	error_count: zod.int(),
+	llm_call_count: zod.int(),
+	started_at: zod.iso.datetime({ offset: true }),
+	tool_call_count: zod.int(),
+	total_tokens: zod.number(),
+	trace_id: zod.string()
+});
+/**
+* DTO for a channel with routing override in rule create/update
+*/
+const zAlertRuleChannelInput = zod.object({
+	integration_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	routing_override: zod.record(zod.string(), zod.unknown()).optional()
+});
+/**
+* Status of an alert delivery attempt
+*/
+const zAlertStatus = zod.enum([
+	"pending",
+	"sent",
+	"failed",
+	"skipped"
+]);
+/**
+* Alert delivery history record (audit log and retry queue)
+*/
+const zAlertHistory = zod.object({
+	alert_rule_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+	alert_type: zod.string(),
+	attempt_count: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	channel_name: zod.string(),
+	channel_type: zod.string(),
+	created_at: zod.iso.datetime({ offset: true }),
+	error_message: zod.string().nullable(),
+	http_status_code: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+	id: zod.int(),
+	idempotency_key: zod.string(),
+	integration_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+	issue_id: zod.uuid().nullable(),
+	next_retry_at: zod.iso.datetime({ offset: true }).nullable(),
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+	sent_at: zod.iso.datetime({ offset: true }).nullable(),
+	status: zAlertStatus
+});
+/**
+* Type of alert trigger
+*/
+const zAlertType = zod.enum([
+	"new_issue",
+	"regression",
+	"unmute"
+]);
+/**
+* Response for alert rule including linked integration info
+*/
+const zAlertRuleResponse = zod.object({
+	alert_type: zAlertType,
+	channels: zod.array(zAlertRuleChannelInput),
+	conditions: zod.record(zod.string(), zod.unknown()),
+	cooldown_minutes: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	created_at: zod.iso.datetime({ offset: true }),
+	id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	integration_ids: zod.array(zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+	is_enabled: zod.boolean(),
+	last_triggered_at: zod.iso.datetime({ offset: true }).nullable(),
+	name: zod.string(),
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	updated_at: zod.iso.datetime({ offset: true })
+});
+const zAssembleBody = zod.object({
+	checksum: zod.string(),
+	chunks: zod.array(zod.string()),
+	projects: zod.array(zod.string())
+});
+const zAssembleResponse = zod.object({
+	detail: zod.string().nullish(),
+	missingChunks: zod.array(zod.string()),
+	state: zod.string()
+});
+/**
+* Response that includes the full token (only on creation)
+*/
+const zAuthTokenCreatedResponse = zod.object({
+	created_at: zod.iso.datetime({ offset: true }),
+	description: zod.string().nullable(),
+	id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	token: zod.string()
+});
+/**
+* Response for listing (token is masked)
+*/
+const zAuthTokenResponse = zod.object({
+	created_at: zod.iso.datetime({ offset: true }),
+	description: zod.string().nullable(),
+	id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	last_used_at: zod.iso.datetime({ offset: true }).nullable(),
+	token_prefix: zod.string()
+});
+/**
+* What the consent page shows about the client asking.
+*/
+const zAuthorizationInfo = zod.object({
+	client_id: zod.string(),
+	client_name: zod.string(),
+	redirect_host: zod.string()
+});
+/**
+* Where the consent page sends the browser next.
+*/
+const zAuthorizationRedirect = zod.object({ redirect_to: zod.string() });
+/**
+* An authorization request, as the client put it in the authorize URL.
+*/
+const zAuthorizationRequest = zod.object({
+	client_id: zod.string(),
+	code_challenge: zod.string(),
+	code_challenge_method: zod.string(),
+	redirect_uri: zod.string(),
+	resource: zod.string().nullish(),
+	response_type: zod.string(),
+	state: zod.string().nullish()
+});
+/**
+* The user's answer to a consent screen.
+*/
+const zAuthorizationDecision = zAuthorizationRequest.and(zod.object({ approve: zod.boolean() }));
+const zBookmarkResponse = zod.object({ is_bookmarked: zod.boolean() });
+const zBulkDeleteResponse = zod.object({ deleted: zod.int() });
+const zBulkUpdateResponse = zod.object({ updated: zod.int() });
+const zChangePasswordRequest = zod.object({
+	current_password: zod.string(),
+	new_password: zod.string()
+});
+/**
+* Status of one check-in. `Missed` and `Timeout` are only ever set by the
+* server.
+*/
+const zCheckInStatus = zod.enum([
+	"ok",
+	"error",
+	"in_progress",
+	"missed",
+	"timeout",
+	"unknown"
+]);
+/**
+* One check-in, as the dashboard reads it.
+*/
+const zCheckInResponse = zod.object({
+	date_added: zod.iso.datetime({ offset: true }),
+	date_updated: zod.iso.datetime({ offset: true }),
+	duration_ms: zod.int().nullable(),
+	environment: zod.string(),
+	expected_time: zod.iso.datetime({ offset: true }).nullable(),
+	id: zod.uuid(),
+	status: zCheckInStatus
+});
+/**
+* Multipart chunk upload.
+* Each part's **field name** may be the SHA-1 hex digest of that part's binary content
+* (sentry-cli v2 protocol, e.g. `da39a3ee5e6b4b0d3255bfef95601890afd80709`) or an arbitrary
+* name like `file` (sentry-cli v3.x). Up to 64 parts per request; each part body is raw binary.
+*/
+const zChunkUploadBody = zod.record(zod.string(), zod.unknown());
+/**
+* Chunk upload capabilities, in sentry-cli's camelCase.
+*/
+const zChunkUploadOptions = zod.object({
+	accept: zod.array(zod.string()),
+	chunkSize: zod.int().gte(0),
+	chunksPerRequest: zod.int().gte(0),
+	compression: zod.array(zod.string()),
+	concurrency: zod.int().gte(0),
+	hashAlgorithm: zod.string(),
+	maxRequestSize: zod.int().gte(0),
+	url: zod.string()
+});
+/**
+* Rows affected by a cleanup, used symmetrically for the dry-run preview ("what
+* would be removed") and the executed result ("what was removed"). `spans` are
+* counted directly even though they cascade from `transactions`, so the UI can
+* show the true row impact. `issues_removed` is the number of issues that would
+* be left with zero events and therefore deleted.
+*/
+const zCleanupCounts = zod.object({
+	events: zod.int(),
+	issues_removed: zod.int(),
+	logs: zod.int(),
+	source_maps: zod.int(),
+	spans: zod.int(),
+	transactions: zod.int()
+});
+/**
+* How often the cleanup that enforces retention runs.
+*/
+const zCleanupFrequency = zod.enum(["daily", "weekly"]);
+/**
+* Request body for a cleanup (preview or execute): remove data older than
+* `older_than_days`, optionally scoped to a single project (omit for all).
+*
+* `older_than_days` must be at least 1 — the service rejects smaller values,
+* since a window of 0 (or negative) would move the cutoff to now/the future and
+* purge the entire dataset.
+*/
+const zCleanupRequest = zod.object({
+	include_events: zod.boolean().optional(),
+	include_logs: zod.boolean().optional(),
+	include_transactions: zod.boolean().optional(),
+	older_than_days: zod.int().gte(1),
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullish()
+});
+/**
+* Where the instance's cleanup job is. There is at most one at a time.
+*/
+const zCleanupState = zod.enum([
+	"idle",
+	"running",
+	"completed",
+	"failed"
+]);
+/**
+* The cleanup job as the API reports it. Kept in memory: a restart forgets
+* it, and a run cut short by one is simply run again, since every batch it
+* committed is already gone.
+*/
+const zCleanupStatus = zod.object({
+	error: zod.string().nullable(),
+	finished_at: zod.iso.datetime({ offset: true }).nullable(),
+	removed: zCleanupCounts,
+	started_at: zod.iso.datetime({ offset: true }).nullable(),
+	state: zCleanupState
+});
+/**
+* Maps a path as it appears in a stack trace to the path in the repository.
+*/
+const zCodeMapping = zod.object({
+	source_root: zod.string(),
+	stack_root: zod.string()
+});
+/**
+* Body for creating an issue comment (note).
+*/
+const zCommentRequest = zod.object({ text: zod.string() });
+const zConfirmSsoLinkRequest = zod.object({ password: zod.string() });
+/**
+* DTO for creating an alert rule
+*/
+const zCreateAlertRule = zod.object({
+	alert_type: zAlertType,
+	channels: zod.array(zAlertRuleChannelInput).optional(),
+	conditions: zod.record(zod.string(), zod.unknown()).optional(),
+	cooldown_minutes: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).optional(),
+	name: zod.string()
+});
+/**
+* DTO for creating a new token
+*/
+const zCreateAuthToken = zod.object({ description: zod.string().nullish() });
+const zCreateGitHubIssue = zod.object({
+	body: zod.string().nullish(),
+	title: zod.string().nullish()
+});
+/**
+* DTO for creating a new project
+*/
+const zCreateProject = zod.object({
+	name: zod.string(),
+	platform: zod.string().nullish(),
+	slug: zod.string().nullish()
+});
+/**
+* DTO for `POST .../releases/`.
+*/
+const zCreateRelease = zod.object({
+	ref: zod.string().nullish(),
+	url: zod.string().nullish(),
+	version: zod.string()
+});
+const zCreateUserRequest = zod.object({
+	email: zod.string(),
+	password: zod.string()
+});
+/**
+* Response for API (full detail)
+*/
+const zEventDetailResponse = zod.object({
+	data: zod.record(zod.string(), zod.unknown()),
+	environment: zod.string(),
+	event_id: zod.string(),
+	event_type: zod.string(),
+	id: zod.uuid(),
+	ingested_at: zod.iso.datetime({ offset: true }),
+	issue_id: zod.uuid().nullable(),
+	level: zod.string(),
+	platform: zod.string(),
+	release: zod.string(),
+	sdk_name: zod.string(),
+	sdk_version: zod.string(),
+	server_name: zod.string(),
+	timestamp: zod.iso.datetime({ offset: true }),
+	title: zod.string()
+});
+zod.object({
+	environment: zod.string(),
+	event_id: zod.string(),
+	event_type: zod.string(),
+	id: zod.uuid(),
+	issue_id: zod.uuid().nullable(),
+	level: zod.string(),
+	platform: zod.string(),
+	release: zod.string(),
+	timestamp: zod.iso.datetime({ offset: true }),
+	title: zod.string()
+});
+/**
+* One time-bucketed point in a project's error-event volume, split by severity.
+*
+* `total` always equals `fatal + error + warning + info`: `info` absorbs
+* `debug` and any level the SDK sent that we do not model, so the stacked
+* segments of a chart always sum to the bar height and no events silently
+* vanish from the series.
+*/
+const zEventTimeseriesPoint = zod.object({
+	bucket: zod.iso.datetime({ offset: true }),
+	error: zod.int(),
+	fatal: zod.int(),
+	info: zod.int(),
+	total: zod.int(),
+	warning: zod.int()
+});
+/**
+* The closed vocabulary a [`FieldError`] may use.
+*
+* Deliberately small and resource-agnostic: a large or per-endpoint
+* vocabulary becomes a public API that cannot be versioned. Adding a variant
+* is a wire change and requires the matching addition to the TypeScript union
+* in `packages/client/src/errors.ts`, which
+* `packages/client/tests/unit/app-error-contract.test.ts` enforces by parsing
+* this enum out of this file.
+*/
+const zFieldErrorCode = zod.enum([
+	"required",
+	"invalid",
+	"already_exists",
+	"too_short",
+	"too_long",
+	"custom"
+]);
+/**
+* One rejected input, named as data rather than buried in the prose of
+* [`ErrorDetail::message`].
+*
+* `field` is a **dot path into the request body** (`slug`,
+* `credentials.webhook_url`), not a JSON Pointer and not a UI label: a
+* consumer feeds it straight to a form library's `setError`.
+*
+* The rejected *value* is deliberately never echoed back. One careless
+* application to a password input would put a credential in the log store.
+*
+* The three fields are private on purpose. [`Self::new`] and [`Self::custom`]
+* are the only ways to build one, which is what makes "`message` is populated
+* only alongside [`FieldErrorCode::Custom`]" an invariant the compiler holds
+* rather than a convention a struct literal could quietly break.
+*/
+const zFieldError = zod.object({
+	code: zFieldErrorCode,
+	field: zod.string(),
+	message: zod.string().optional()
+});
+const zErrorDetail = zod.object({
+	fields: zod.array(zFieldError).optional(),
+	incident_id: zod.string().optional(),
+	message: zod.string(),
+	type: zod.string()
+});
+zod.object({ error: zErrorDetail });
+/**
+* One row of a "top N by X" breakdown (model or tool name).
+*/
+const zGenAiBreakdownRow = zod.object({
+	label: zod.string(),
+	value: zod.number()
+});
+const zGitHubAppInfo = zod.object({
+	app_id: zod.int(),
+	created_at: zod.iso.datetime({ offset: true }),
+	html_url: zod.string(),
+	install_url: zod.string(),
+	last_webhook_at: zod.iso.datetime({ offset: true }).nullable(),
+	owner_login: zod.string(),
+	slug: zod.string()
+});
+const zGitHubInstallation = zod.object({
+	account_login: zod.string(),
+	account_type: zod.string(),
+	created_at: zod.iso.datetime({ offset: true }),
+	id: zod.int(),
+	suspended: zod.boolean()
+});
+const zGitHubLogin = zod.object({ login: zod.string().nullable() });
+/**
+* A repository an installation can reach.
+*/
+const zGitHubRepository = zod.object({
+	default_branch: zod.string(),
+	full_name: zod.string(),
+	html_url: zod.string(),
+	installation_id: zod.int(),
+	private: zod.boolean()
+});
+/**
+* `GET /api/github`: everything the integrations page needs in one answer.
+*/
+const zGitHubStatus = zod.object({
+	app: zGitHubAppInfo.nullable(),
+	installations: zod.array(zGitHubInstallation),
+	webhook_url: zod.string()
+});
+/**
+* Grouping model - maps a grouping key to an issue
+*/
+const zGrouping = zod.object({
+	created_at: zod.iso.datetime({ offset: true }),
+	grouping_key: zod.string(),
+	grouping_key_hash: zod.string(),
+	id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid(),
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+});
+const zIntervalUnit = zod.enum([
+	"minute",
+	"hour",
+	"day",
+	"week",
+	"month",
+	"year"
+]);
+/**
+* Filter for issues listing
+*/
+const zIssueFilter = zod.enum([
+	"open",
+	"resolved",
+	"muted",
+	"all"
+]);
+/**
+* Bulk delete request: the listed `ids`, or every issue matching `filter`.
+* A body with neither or both matches no variant and is rejected, so an empty
+* body can never mean "all".
+*/
+const zBulkDeleteIssues = zod.union([zod.object({ ids: zod.array(zod.uuid()) }), zod.object({ filter: zIssueFilter })]);
+const zIssueLink = zod.object({
+	created_at: zod.iso.datetime({ offset: true }),
+	id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid(),
+	number: zod.int(),
+	repo_full_name: zod.string(),
+	state: zod.string(),
+	title: zod.string(),
+	url: zod.string()
+});
+/**
+* Triage priority of an issue.
+*/
+const zIssuePriority = zod.enum([
+	"low",
+	"medium",
+	"high"
+]);
+/**
+* Sort mode for issues listing
+*/
+const zIssueSort = zod.enum([
+	"digest_order",
+	"last_seen",
+	"event_count"
+]);
+const zIssueStatsResponse = zod.object({ data: zod.array(zod.array(zod.int())) });
+/**
+* How far back issue stats reach.
+*/
+const zIssueStatsWindow = zod.enum(["24h", "30d"]);
+/**
+* Lifecycle status of an issue (Sentry-compatible).
+*/
+const zIssueStatus = zod.enum([
+	"unresolved",
+	"resolved",
+	"ignored"
+]);
+/**
+* Response for API
+*/
+const zIssueResponse = zod.object({
+	assigned_to: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+	assignee_type: zod.string().nullable(),
+	culprit: zod.string(),
+	event_count: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	first_release: zod.string(),
+	first_seen: zod.iso.datetime({ offset: true }),
+	has_seen: zod.boolean().nullish(),
+	id: zod.uuid(),
+	is_bookmarked: zod.boolean().nullish(),
+	is_muted: zod.boolean(),
+	is_resolved: zod.boolean(),
+	is_subscribed: zod.boolean().nullish(),
+	issue_category: zod.string(),
+	issue_type: zod.string(),
+	last_release: zod.string(),
+	last_seen: zod.iso.datetime({ offset: true }),
+	level: zod.string().nullable(),
+	logger: zod.string(),
+	platform: zod.string().nullable(),
+	priority: zIssuePriority.nullable(),
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	short_id: zod.string(),
+	status: zIssueStatus,
+	status_details: zod.record(zod.string(), zod.unknown()),
+	substatus: zod.string().nullable(),
+	title: zod.string(),
+	trend: zod.array(zod.int()).nullish(),
+	user_count: zod.int().nullish(),
+	user_report_count: zod.int().nullish(),
+	value: zod.string()
+});
+/**
+* The status an update may set: an [`IssueStatus`], or `resolvedInNextRelease`
+* to resolve until the next release ships.
+*/
+const zIssueStatusUpdate = zod.enum([
+	"unresolved",
+	"resolved",
+	"ignored",
+	"resolvedInNextRelease"
+]);
+/**
+* Bulk mutate request: apply a status (and/or priority) to many issues.
+*/
+const zBulkUpdateIssues = zod.object({
+	ids: zod.array(zod.uuid()),
+	priority: zIssuePriority.nullish(),
+	status: zIssueStatusUpdate.nullish()
+});
+/**
+* A single tag value's usage within an issue — the shape `GET
+* /issues/{id}/tags/{key}` returns per entry, matching Sentry's
+* `TagValueSerializerResponse` (src/sentry/tagstore/types.py:166-173):
+* a bare list of these, not `{key, values}`.
+*/
+const zIssueTagValue = zod.object({
+	count: zod.int(),
+	first_seen: zod.iso.datetime({ offset: true }),
+	key: zod.string(),
+	last_seen: zod.iso.datetime({ offset: true }),
+	name: zod.string(),
+	value: zod.string()
+});
+/**
+* Body of an issue update: the fields of `GroupValidator`
+* (`api/helpers/group_index/validators/group.py`) Rustrak acts on.
+*/
+const zIssueUpdate = zod.object({
+	status: zod.string().nullish(),
+	substatus: zod.string().nullish()
+});
+/**
+* How long ago a kind of data arrived: rows per age bucket, and the oldest.
+*/
+const zKindAge = zod.object({
+	counts: zod.array(zod.int()),
+	oldest: zod.iso.datetime({ offset: true }).nullable()
+});
+const zLinkGitHubIssue = zod.object({ reference: zod.string() });
+const zLivenessResponse = zod.object({ status: zod.string() });
+zod.object({
+	attributes: zod.record(zod.string(), zod.unknown()),
+	body: zod.string(),
+	id: zod.uuid(),
+	ingested_at: zod.iso.datetime({ offset: true }),
+	level: zod.string(),
+	severity_number: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+	span_id: zod.string().nullable(),
+	timestamp: zod.iso.datetime({ offset: true }),
+	trace_id: zod.string().nullable()
+});
+const zLoginRequest = zod.object({
+	email: zod.string(),
+	password: zod.string()
+});
+const zManifestRequest = zod.object({ organization: zod.string().nullish() });
+/**
+* What the dashboard posts to GitHub to create the app.
+*/
+const zManifestResponse = zod.object({
+	action_url: zod.string(),
+	manifest: zod.string()
+});
+/**
+* Turns `/mcp` on or off: the body of `PUT /api/settings/mcp`.
+*/
+const zMcpSettings = zod.object({ enabled: zod.boolean() });
+/**
+* Whether `/mcp` answers, and the URL to give an assistant.
+*/
+const zMcpStatus = zod.object({
+	enabled: zod.boolean(),
+	url: zod.string().nullable()
+});
+/**
+* A counter measured over the requested window alongside the same counter
+* over the window immediately before it.
+*
+* `previous` is `None` when the request asked for all time: there is no
+* earlier window to compare against, and reporting `0` there would render as
+* a misleading "+100%" in the UI.
+*/
+const zMetricDelta = zod.object({
+	current: zod.int(),
+	previous: zod.int().nullable()
+});
+/**
+* Health of one monitor environment.
+*/
+const zMonitorEnvironmentStatus = zod.enum([
+	"active",
+	"ok",
+	"error"
+]);
+/**
+* One environment of a monitor, with its most recent check-ins for the
+* timeline.
+*/
+const zMonitorEnvironmentResponse = zod.object({
+	environment: zod.string(),
+	id: zod.uuid(),
+	last_checkin: zod.iso.datetime({ offset: true }).nullable(),
+	next_checkin: zod.iso.datetime({ offset: true }).nullable(),
+	next_checkin_latest: zod.iso.datetime({ offset: true }).nullable(),
+	recent_checkins: zod.array(zCheckInResponse),
+	status: zMonitorEnvironmentStatus
+});
+/**
+* A connected client, as its user sees it.
+*/
+const zOAuthGrant = zod.object({
+	client_id: zod.string(),
+	client_name: zod.string(),
+	created_at: zod.iso.datetime({ offset: true }),
+	id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+});
+/**
+* Synthetic organization sentry-cli checks before uploading.
+*/
+const zOrgDetails = zod.object({
+	features: zod.array(zod.string()),
+	id: zod.string(),
+	name: zod.string(),
+	slug: zod.string()
+});
+/**
+* Body of a template preview request.
+*/
+const zPreviewTemplateBody = zod.object({ template: zod.string() });
+/**
+* `rendered` when `ok`, `error` otherwise.
+*/
+const zPreviewTemplateResponse = zod.object({
+	error: zod.string().nullish(),
+	ok: zod.boolean(),
+	rendered: zod.string().nullish()
+});
+const zProjectAge = zod.object({
+	events: zKindAge,
+	logs: zKindAge,
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	transactions: zKindAge
+});
+/**
+* The at-a-glance aggregates one row of the project-list table needs.
+*
+* Deliberately narrower than [`ProjectStatsSummary`]: that one answers "how
+* is this project doing" for a page dedicated to a single project, this one
+* answers "which of my projects should I look at first" and must stay cheap
+* enough to compute for every project on the page at once.
+*/
+const zProjectListStats = zod.object({
+	events: zMetricDelta,
+	fatal_issues: zod.int(),
+	new_issues: zMetricDelta,
+	open_issues: zod.int(),
+	trend: zod.array(zod.int())
+});
+const zProjectRepository = zod.object({
+	auto_create_conditions: zod.record(zod.string(), zod.unknown()),
+	auto_create_issues: zod.boolean(),
+	code_mappings: zod.array(zCodeMapping),
+	codeowners_rules: zod.int().gte(0).nullable(),
+	codeowners_synced_at: zod.iso.datetime({ offset: true }).nullable(),
+	default_branch: zod.string(),
+	html_url: zod.string(),
+	installation_id: zod.int(),
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	repo_full_name: zod.string()
+});
+/**
+* Response with DSN included
+*/
+const zProjectResponse = zod.object({
+	created_at: zod.iso.datetime({ offset: true }),
+	digested_event_count: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	dsn: zod.string(),
+	id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	name: zod.string(),
+	platform: zod.string().nullable(),
+	rate_limit_per_hour: zod.int().nullable(),
+	rate_limit_per_minute: zod.int().nullable(),
+	rate_limited_event_count: zod.int(),
+	sentry_key: zod.uuid(),
+	slug: zod.string(),
+	stats: zProjectListStats.nullish(),
+	stored_event_count: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	updated_at: zod.iso.datetime({ offset: true })
+});
+/**
+* A project that keeps its data for other windows than the defaults. Every
+* kind is set: an override replaces the defaults whole.
+*/
+const zProjectRetention = zod.object({
+	events_days: zod.int().nullable(),
+	logs_days: zod.int().nullable(),
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	transactions_days: zod.int().nullable()
+});
+/**
+* Per-project capability level for a member.
+*
+* Ordered by privilege: `Viewer` < `Editor` < `Admin` (derived `Ord` uses
+* declaration order). An `Action` maps to the minimum role that may perform it.
+*/
+const zProjectRole = zod.enum([
+	"viewer",
+	"editor",
+	"admin"
+]);
+const zProjectMember = zod.object({
+	created_at: zod.iso.datetime({ offset: true }),
+	id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	role: zProjectRole,
+	user_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+});
+/**
+* Member row joined with the user's email, for listing a project's team.
+*/
+const zProjectMemberResponse = zod.object({
+	created_at: zod.iso.datetime({ offset: true }),
+	email: zod.string(),
+	role: zProjectRole,
+	user_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+});
+/**
+* Project-wide counters for the overview page, each with its previous-period
+* comparison.
+*/
+const zProjectStatsSummary = zod.object({
+	events: zMetricDelta,
+	new_issues: zMetricDelta,
+	open_issues: zod.int(),
+	period_hours: zod.int().nullable()
+});
+zod.object({
+	estimated_bytes: zod.int(),
+	events_bytes: zod.int(),
+	events_count: zod.int(),
+	logs_bytes: zod.int(),
+	logs_count: zod.int(),
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	project_name: zod.string(),
+	source_maps_count: zod.int(),
+	spans_count: zod.int(),
+	transactions_bytes: zod.int(),
+	transactions_count: zod.int()
+});
+/**
+* Type of notification provider (replaces ChannelType)
+*/
+const zProviderType = zod.enum([
+	"webhook",
+	"email",
+	"slack",
+	"custom_webhook"
+]);
+/**
+* Global alert integration record — stores credentials only, no routing.
+*/
+const zAlertIntegration = zod.object({
+	created_at: zod.iso.datetime({ offset: true }),
+	credentials: zod.record(zod.string(), zod.unknown()),
+	failure_count: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	is_enabled: zod.boolean(),
+	last_failure_at: zod.iso.datetime({ offset: true }).nullable(),
+	last_failure_message: zod.string().nullable(),
+	last_success_at: zod.iso.datetime({ offset: true }).nullable(),
+	name: zod.string(),
+	provider_type: zProviderType,
+	updated_at: zod.iso.datetime({ offset: true })
+});
+/**
+* DTO for creating an alert integration
+*/
+const zCreateAlertIntegration = zod.object({
+	credentials: zod.record(zod.string(), zod.unknown()),
+	is_enabled: zod.boolean().optional(),
+	name: zod.string(),
+	provider_type: zProviderType
+});
+/**
+* Configure project routes
+* The server's per-project event limits (`MAX_EVENTS_PER_PROJECT_*`).
+*/
+const zRateLimitsResponse = zod.object({
+	project_per_hour: zod.int(),
+	project_per_minute: zod.int()
+});
+const zReadinessChecks = zod.object({ database: zod.string() });
+const zReadinessResponse = zod.object({
+	checks: zReadinessChecks,
+	status: zod.string()
+});
+zod.object({
+	abnormal: zod.int(),
+	crash_free_sessions_rate: zod.number().nullable(),
+	crash_free_users_rate: zod.number().nullable(),
+	crashed: zod.int(),
+	environment: zod.string(),
+	errored: zod.int(),
+	healthy: zod.int(),
+	release: zod.string(),
+	total: zod.int()
+});
+/**
+* API response for a release.
+*/
+const zReleaseResponse = zod.object({
+	dateCreated: zod.iso.datetime({ offset: true }),
+	dateReleased: zod.iso.datetime({ offset: true }).nullable(),
+	ref: zod.string().nullable(),
+	url: zod.string().nullable(),
+	version: zod.string()
+});
+const zRepoCommit = zod.object({
+	author_login: zod.string().nullable(),
+	author_name: zod.string(),
+	committed_at: zod.iso.datetime({ offset: true }),
+	message: zod.string(),
+	repo_full_name: zod.string(),
+	sha: zod.string(),
+	url: zod.string()
+});
+/**
+* `GET .../issues/{id}/github`: the issue's "Code" block in one answer.
+*/
+const zIssueGitHub = zod.object({
+	links: zod.array(zIssueLink),
+	owners: zod.array(zod.string()),
+	suspect_commits: zod.array(zRepoCommit)
+});
+/**
+* How the last retention cleanup went.
+*/
+const zRetentionRun = zod.object({
+	error: zod.string().nullable(),
+	finished_at: zod.iso.datetime({ offset: true }).nullable(),
+	removed: zCleanupCounts.nullable(),
+	started_at: zod.iso.datetime({ offset: true }),
+	status: zod.string()
+});
+/**
+* How long each kind of data is kept, in days. `None` keeps it forever.
+*/
+const zRetentionWindows = zod.object({
+	events_days: zod.int().nullable().default(null),
+	logs_days: zod.int().nullable().default(null),
+	transactions_days: zod.int().nullable().default(null)
+});
+/**
+* Retention: how long each kind of data is kept, by default and per
+* project, and when the cleanup that enforces it runs. Stored as the
+* settings of the `storage_cleanup` scheduled job; a field left out takes
+* its default. Keeping everything forever runs nothing.
+*/
+const zRetentionSettings = zod.object({
+	defaults: zRetentionWindows.default({
+		events_days: null,
+		logs_days: null,
+		transactions_days: null
+	}),
+	frequency: zCleanupFrequency.default("daily"),
+	hour: zod.int().gte(0).lte(23).default(3),
+	overrides: zod.array(zProjectRetention).default([]),
+	weekday: zod.int().gte(0).lte(6).default(0)
+});
+const zRetentionResponse = zod.object({
+	last_run: zRetentionRun.nullable(),
+	next_run_at: zod.iso.datetime({ offset: true }).nullable(),
+	settings: zRetentionSettings
+});
+const zSchedule = zod.union([zod.object({
+	type: zod.enum(["crontab"]),
+	value: zod.string()
+}), zod.object({
+	type: zod.enum(["interval"]),
+	unit: zIntervalUnit,
+	value: zod.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+})]);
+/**
+* A validated monitor configuration, with every default filled in.
+*/
+const zMonitorConfig = zod.object({
+	checkin_margin: zod.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	failure_issue_threshold: zod.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	max_runtime: zod.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	recovery_threshold: zod.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	schedule: zSchedule,
+	timezone: zod.string()
+});
+/**
+* `monitor_config` as an SDK or the dashboard sends it: every field optional.
+*/
+const zMonitorConfigInput = zod.object({
+	checkin_margin: zod.int().gte(0).nullish(),
+	failure_issue_threshold: zod.int().gte(0).nullish(),
+	max_runtime: zod.int().gte(0).nullish(),
+	recovery_threshold: zod.int().gte(0).nullish(),
+	schedule: zSchedule.nullish(),
+	timezone: zod.string().nullish()
+});
+/**
+* Body of `POST /api/projects/{project_id}/monitors`.
+*/
+const zCreateMonitor = zod.object({
+	config: zMonitorConfigInput,
+	name: zod.string(),
+	slug: zod.string().nullish()
+});
+const zMonitorResponse = zod.object({
+	config: zMonitorConfig,
+	created_at: zod.iso.datetime({ offset: true }),
+	environments: zod.array(zMonitorEnvironmentResponse),
+	id: zod.uuid(),
+	is_muted: zod.boolean(),
+	name: zod.string(),
+	slug: zod.string()
+});
+/**
+* Body of `POST /api/schedules/preview`.
+*/
+const zPreviewSchedule = zod.object({
+	schedule: zSchedule,
+	timezone: zod.string().nullish()
+});
+/**
+* When a schedule runs next, computed by the code that runs it: monitors
+* expect their check-ins and scheduled jobs fire at exactly these instants.
+*/
+const zSchedulePreview = zod.object({ next_runs: zod.array(zod.iso.datetime({ offset: true })) });
+const zSeenResponse = zod.object({ has_seen: zod.boolean() });
+/**
+* `GroupProjectResponse` (`api/serializers/models/group.py`).
+*/
+const zSentryGroupProject = zod.object({
+	id: zod.string(),
+	name: zod.string(),
+	platform: zod.string().nullable(),
+	slug: zod.string()
+});
+/**
+* Subset of `GroupSerializer` plus its seen stats
+* (`api/serializers/models/group.py`), and `stats` when the caller asked
+* for a series (`StreamGroupSerializer`, `group_stream.py`).
+*/
+const zSentryIssue = zod.object({
+	annotations: zod.array(zod.record(zod.string(), zod.unknown())),
+	count: zod.string(),
+	culprit: zod.string(),
+	firstSeen: zod.iso.datetime({ offset: true }),
+	id: zod.string(),
+	issueCategory: zod.string(),
+	issueType: zod.string(),
+	lastSeen: zod.iso.datetime({ offset: true }),
+	level: zod.string(),
+	logger: zod.string().nullable(),
+	metadata: zod.record(zod.string(), zod.unknown()),
+	platform: zod.string().nullable(),
+	priority: zod.string().nullable(),
+	project: zSentryGroupProject,
+	shortId: zod.string(),
+	stats: zod.record(zod.string(), zod.unknown()).nullish(),
+	status: zod.string(),
+	statusDetails: zod.record(zod.string(), zod.unknown()),
+	substatus: zod.string().nullable(),
+	title: zod.string(),
+	type: zod.string(),
+	userCount: zod.int()
+});
+/**
+* A release as `serialize_releases` (`api/helpers/group_index/index.py`)
+* falls back to it, with the serializer's `shortVersion`, which is the
+* version itself (`api/serializers/models/release.py`).
+*/
+const zSentryRelease = zod.object({
+	shortVersion: zod.string(),
+	version: zod.string()
+});
+/**
+* Subset of `GroupDetailsEndpoint`'s response
+* (`issues/endpoints/group_details.py`).
+*/
+const zSentryIssueDetails = zSentryIssue.and(zod.object({
+	firstRelease: zSentryRelease.nullable(),
+	lastRelease: zSentryRelease.nullable(),
+	userReportCount: zod.int()
+}));
+/**
+* `{"id", "name"}` of a status, as Sentry nests it in an organization.
+*/
+const zSentryStatus = zod.object({
+	id: zod.string(),
+	name: zod.string()
+});
+/**
+* Subset of `OrganizationSummarySerializer`
+* (`api/serializers/models/organization.py`).
+*/
+const zSentryOrganization = zod.object({
+	id: zod.string(),
+	name: zod.string(),
+	slug: zod.string(),
+	status: zSentryStatus
+});
+/**
+* Subset of `ProjectWithOrganizationSerializer`
+* (`api/serializers/models/project.py`). Sentry's ids are strings.
+*/
+const zSentryProject = zod.object({
+	dateCreated: zod.iso.datetime({ offset: true }),
+	id: zod.string(),
+	name: zod.string(),
+	organization: zSentryOrganization,
+	platform: zod.string().nullable(),
+	slug: zod.string(),
+	status: zod.string()
+});
+const zSentryTag = zod.object({
+	key: zod.string(),
+	value: zod.string()
+});
+/**
+* Subset of `EventSerializer` for an error event
+* (`api/serializers/models/event.py`).
+*/
+const zSentryEvent = zod.object({
+	culprit: zod.string(),
+	dateCreated: zod.iso.datetime({ offset: true }),
+	dateReceived: zod.iso.datetime({ offset: true }),
+	entries: zod.array(zod.record(zod.string(), zod.unknown())),
+	eventID: zod.string(),
+	groupID: zod.string(),
+	id: zod.string(),
+	message: zod.string(),
+	metadata: zod.record(zod.string(), zod.unknown()),
+	platform: zod.string(),
+	projectID: zod.string(),
+	tags: zod.array(zSentryTag),
+	title: zod.string(),
+	type: zod.string()
+});
+/**
+* Project-wide session health summary, aggregated across all releases and environments.
+*/
+const zSessionSummary = zod.object({
+	abnormal: zod.int(),
+	active_releases: zod.int(),
+	crash_free_sessions_rate: zod.number().nullable(),
+	crash_free_users_rate: zod.number().nullable(),
+	crashed: zod.int(),
+	errored: zod.int(),
+	total: zod.int()
+});
+/**
+* One time-bucketed point in a project's session trend, aggregated across all
+* releases and environments. Powers trend charts (crash-free sessions over time).
+*/
+const zSessionTimeseriesPoint = zod.object({
+	bucket: zod.iso.datetime({ offset: true }),
+	crash_free_sessions_rate: zod.number().nullable(),
+	crashed: zod.int(),
+	total: zod.int()
+});
+/**
+* Sort order direction
+*/
+const zSortOrder = zod.enum(["asc", "desc"]);
+const zSourceMapFile = zod.object({
+	dateUploaded: zod.string(),
+	debugId: zod.string(),
+	fileType: zod.string(),
+	size: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	timesUsed: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+});
+/**
+* Outcome of a source-map garbage collection: orphaned `source_file` rows
+* (no `source_file_metadata` referencing them) removed from the DB and unlinked
+* from disk. `bytes_freed` is the exact summed `size` of the removed files.
+*/
+const zSourceMapGcResult = zod.object({
+	bytes_freed: zod.int(),
+	files_removed: zod.int()
+});
+const zSourceMapList = zod.object({ data: zod.array(zSourceMapFile) });
+/**
+* Exact source-map storage weight, summed from the `size` columns.
+*
+* Source maps live in two places: `chunk` holds the raw upload bytes as in-DB
+* BYTEA, `source_file` holds the assembled artifact on the filesystem CAS. Both
+* carry a `size` column, so the weight is an exact SUM — no filesystem walk.
+*/
+const zSourceMapStorage = zod.object({
+	chunk_bytes: zod.int(),
+	file_count: zod.int(),
+	source_file_bytes: zod.int(),
+	total_bytes: zod.int()
+});
+/**
+* A single indexed span — extracted from a transaction, OR standalone
+* (Sentry "span" item type). Both origins write into the same `spans`
+* table, so `transaction_id` is the only thing that distinguishes them.
+*/
+const zSpanResponse = zod.object({
+	description: zod.string().nullable(),
+	duration_ms: zod.number().nullable(),
+	environment: zod.string().nullable(),
+	exclusive_time_ms: zod.number().nullable(),
+	gen_ai_agent_name: zod.string().nullable(),
+	gen_ai_conversation_id: zod.string().nullable(),
+	gen_ai_operation_type: zod.string().nullable(),
+	gen_ai_request_model: zod.string().nullable(),
+	gen_ai_response_model: zod.string().nullable(),
+	gen_ai_tool_name: zod.string().nullable(),
+	gen_ai_usage_input_tokens: zod.number().nullable(),
+	gen_ai_usage_output_tokens: zod.number().nullable(),
+	gen_ai_usage_total_tokens: zod.number().nullable(),
+	id: zod.uuid(),
+	is_segment: zod.boolean(),
+	op: zod.string().nullable(),
+	parent_span_id: zod.string().nullable(),
+	platform: zod.string().nullable(),
+	release: zod.string().nullable(),
+	segment_id: zod.string().nullable(),
+	span_id: zod.string().nullable(),
+	start_timestamp: zod.iso.datetime({ offset: true }).nullable(),
+	status: zod.string().nullable(),
+	timestamp: zod.iso.datetime({ offset: true }).nullable(),
+	trace_id: zod.string().nullable(),
+	transaction_id: zod.uuid().nullable()
+});
+/**
+* One span with its full attribute bag — the detail counterpart to
+* [`SpanResponse`].
+*
+* The list response deliberately omits attributes: `spans.data` is never
+* trimmed (unlike event data, which goes through `services::event_trim`), so
+* a single AI span can carry a whole prompt and a trace's worth of them would
+* dwarf the waterfall it is drawn from. Attributes are fetched one span at a
+* time instead, which is also how Sentry's own agent drawer works — the span
+* list is light and the details panel loads the selected node's attributes.
+*/
+const zSpanDetailResponse = zSpanResponse.and(zod.object({
+	attributes: zod.record(zod.string(), zod.unknown()),
+	tags: zod.record(zod.string(), zod.unknown()).nullable()
+}));
+const zSsoConfigResponse = zod.object({
+	enabled: zod.boolean(),
+	provider_name: zod.string().nullable()
+});
+const zSsoLinkResponse = zod.object({
+	email: zod.string(),
+	provider_name: zod.string()
+});
+const zSsoStartResponse = zod.object({ authorization_url: zod.string() });
+/**
+* The age of everything the instance holds, by project and kind, keyed on
+* ingest time like retention.
+*/
+const zStorageAge = zod.object({
+	bucket_days: zod.array(zod.int()),
+	projects: zod.array(zProjectAge)
+});
+/**
+* Instance-wide storage summary: what Rustrak is holding right now.
+*
+* Row counts are exact (indexed `COUNT(*)`). `total_db_size_bytes` is a
+* best-effort figure from the backend (`pg_database_size` / SQLite page count),
+* while `source_maps` is exact (summed `size` columns).
+*/
+const zStorageSummary = zod.object({
+	events_count: zod.int(),
+	logs_count: zod.int(),
+	source_maps: zSourceMapStorage,
+	spans_count: zod.int(),
+	total_db_size_bytes: zod.int(),
+	transactions_count: zod.int()
+});
+const zSubscriptionResponse = zod.object({ is_subscribed: zod.boolean() });
+/**
+* A tag value with its event count within an issue.
+*/
+const zTagValueCount = zod.object({
+	count: zod.int(),
+	value: zod.string()
+});
+/**
+* A tag key with its most common values within an issue.
+*/
+const zTagSummary = zod.object({
+	key: zod.string(),
+	top_values: zod.array(zTagValueCount),
+	total_values: zod.int().gte(0)
+});
+/**
+* Per-issue aggregates computed from recent events (capped scan).
+*/
+const zIssueAggregates = zod.object({
+	tags: zod.array(zTagSummary),
+	user_count: zod.int()
+});
+const zTelemetryPreview = zod.object({
+	enabled: zod.boolean(),
+	reason: zod.string().nullable(),
+	report: zod.record(zod.string(), zod.unknown()),
+	sink: zod.string().nullable()
+});
+/**
+* Outcome of a test notification.
+*/
+const zTestChannelResponse = zod.object({
+	message: zod.string(),
+	response_body: zod.string().nullable(),
+	success: zod.boolean()
+});
+/**
+* Request body for the test-integration endpoint.
+*/
+const zTestIntegrationBody = zod.object({ routing_override: zod.record(zod.string(), zod.unknown()).nullish() });
+/**
+* Body for toggling a per-user flag (bookmark/subscription).
+*/
+const zToggleRequest = zod.object({ enabled: zod.boolean().nullish() });
+/**
+* Response model for a single transaction detail view.
+*
+* Carries the same summary fields as [`TransactionResponse`] plus the full
+* Sentry payload under `data` (spans, contexts.trace, measurements, tags,
+* request, user). The frontend builds the span waterfall and metrics view
+* from `data`.
+*/
+const zTransactionDetailResponse = zod.object({
+	data: zod.record(zod.string(), zod.unknown()),
+	duration_ms: zod.number().nullable(),
+	environment: zod.string(),
+	event_id: zod.string(),
+	id: zod.uuid(),
+	ingested_at: zod.iso.datetime({ offset: true }),
+	platform: zod.string(),
+	release: zod.string(),
+	start_timestamp: zod.iso.datetime({ offset: true }).nullable(),
+	timestamp: zod.iso.datetime({ offset: true }),
+	transaction_name: zod.string()
+});
+zod.object({
+	duration_ms: zod.number().nullable(),
+	environment: zod.string(),
+	event_id: zod.string(),
+	id: zod.uuid(),
+	ingested_at: zod.iso.datetime({ offset: true }),
+	platform: zod.string(),
+	release: zod.string(),
+	start_timestamp: zod.iso.datetime({ offset: true }).nullable(),
+	timestamp: zod.iso.datetime({ offset: true }),
+	transaction_name: zod.string()
+});
+/**
+* Aggregate performance stats for one (transaction_name, op) group.
+* Powers the performance overview: throughput + latency percentiles +
+* failure rate per transaction. Percentiles are continuous (linear
+* interpolation, matching Postgres `percentile_cont`).
+*/
+const zTransactionStatsResponse = zod.object({
+	count: zod.int(),
+	failure_rate: zod.number(),
+	op: zod.string().nullable(),
+	p50_ms: zod.number(),
+	p95_ms: zod.number(),
+	p99_ms: zod.number(),
+	transaction_name: zod.string()
+});
+/**
+* DTO for updating an alert integration
+*/
+const zUpdateAlertIntegration = zod.object({
+	credentials: zod.record(zod.string(), zod.unknown()).nullish(),
+	is_enabled: zod.boolean().nullish(),
+	name: zod.string().nullish()
+});
+/**
+* DTO for updating an alert rule
+*/
+const zUpdateAlertRule = zod.object({
+	channels: zod.array(zAlertRuleChannelInput).nullish(),
+	conditions: zod.record(zod.string(), zod.unknown()).nullish(),
+	cooldown_minutes: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullish(),
+	is_enabled: zod.boolean().nullish(),
+	name: zod.string().nullish()
+});
+/**
+* Request to update issue state.
+*
+* `status`/`substatus`/`priority`/assignment are the canonical fields.
+* `is_resolved`/`is_muted` are accepted as a deprecated compatibility shim
+* and mapped onto `status`.
+*/
+const zUpdateIssueState = zod.object({
+	assigned_to: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullish(),
+	assignee_type: zod.string().nullish(),
+	is_muted: zod.boolean().nullish(),
+	is_resolved: zod.boolean().nullish(),
+	priority: zIssuePriority.nullish(),
+	status: zIssueStatusUpdate.nullish(),
+	substatus: zod.string().nullish()
+});
+/**
+* Body of `PUT /api/projects/{project_id}/monitors/{slug}`. Fields left out
+* keep their value, including each field of `config`.
+*/
+const zUpdateMonitor = zod.object({
+	config: zMonitorConfigInput.nullish(),
+	is_muted: zod.boolean().nullish(),
+	name: zod.string().nullish()
+});
+/**
+* What a reader may change about how the dashboard is presented to them.
+*
+* Every field is doubly optional, and both levels are used: absent means
+* "leave it", `null` means "clear it". `#[serde(default)]` with
+* `deserialize_with` is what keeps those distinguishable, because plain
+* `Option<Option<T>>` collapses a missing key and an explicit null.
+*/
+const zUpdatePreferencesRequest = zod.object({
+	language: zod.string().nullish(),
+	timezone: zod.string().nullish()
+});
+/**
+* DTO for updating a project
+*/
+const zUpdateProject = zod.object({
+	name: zod.string().nullish(),
+	platform: zod.string().nullish(),
+	rate_limit_per_hour: zod.int().nullish(),
+	rate_limit_per_minute: zod.int().nullish(),
+	slug: zod.string().nullish()
+});
+const zUpdateProjectRepository = zod.object({
+	auto_create_conditions: zod.record(zod.string(), zod.unknown()).nullish(),
+	auto_create_issues: zod.boolean().nullish(),
+	code_mappings: zod.array(zCodeMapping).nullish(),
+	installation_id: zod.int(),
+	repo_full_name: zod.string()
+});
+/**
+* DTO for `PUT .../releases/{version}/` — generic partial update.
+* Setting `date_released` IS "finalize": there is no separate status flag.
+* Absent fields (including an explicit `null`) leave the stored value
+* unchanged, matching Sentry's own partial-update semantics for this endpoint.
+*/
+const zUpdateRelease = zod.object({
+	dateReleased: zod.iso.datetime({ offset: true }).nullish(),
+	ref: zod.string().nullish(),
+	url: zod.string().nullish()
+});
+const zUpsertProjectMember = zod.object({
+	role: zProjectRole,
+	user_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+});
+/**
+* A user feedback report attached to a project/issue/event.
+*/
+const zUserReport = zod.object({
+	comments: zod.string(),
+	created_at: zod.iso.datetime({ offset: true }),
+	email: zod.string(),
+	event_id: zod.uuid().nullable(),
+	id: zod.uuid(),
+	issue_id: zod.uuid().nullable(),
+	name: zod.string(),
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+});
+/**
+* Body for submitting user feedback on an issue.
+*/
+const zUserReportRequest = zod.object({
+	comments: zod.string().nullish(),
+	email: zod.string().nullish(),
+	event_id: zod.uuid().nullish(),
+	name: zod.string().nullish()
+});
+/**
+* Instance-wide role for a user.
+*
+* `Admin` has full access to every project and to team management.
+* `Member` only sees projects they are a member of (see `ProjectRole`).
+*/
+const zUserRole = zod.enum(["admin", "member"]);
+const zCreateInvitation = zod.object({
+	email: zod.string(),
+	role: zUserRole
+});
+/**
+* Public-facing invitation info for the accept page.
+*/
+const zInvitationInfoResponse = zod.object({
+	email: zod.string(),
+	expires_at: zod.iso.datetime({ offset: true }),
+	role: zUserRole,
+	status: zod.string()
+});
+/**
+* Public-facing invitation (no internal columns beyond what the UI needs).
+*/
+const zInvitationResponse = zod.object({
+	created_at: zod.iso.datetime({ offset: true }),
+	email: zod.string(),
+	expires_at: zod.iso.datetime({ offset: true }),
+	role: zUserRole,
+	status: zod.string(),
+	token: zod.string()
+});
+/**
+* A user as exposed on the team roster.
+*/
+const zTeamMemberResponse = zod.object({
+	created_at: zod.iso.datetime({ offset: true }),
+	email: zod.string(),
+	id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	is_active: zod.boolean(),
+	is_primary: zod.boolean(),
+	last_login: zod.iso.datetime({ offset: true }).nullable(),
+	role: zUserRole
+});
+/**
+* Request body for changing a user's global role.
+*/
+const zUpdateUserRole = zod.object({ role: zUserRole });
+const zUserResponse = zod.object({
+	email: zod.string(),
+	id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	is_admin: zod.boolean(),
+	language: zod.string().nullable(),
+	role: zUserRole,
+	timezone: zod.string().nullable()
+});
+const zAuthResponse = zod.object({ user: zUserResponse });
+const zVersionResponse = zod.object({ version: zod.string() });
+const zSentryGetIssuePath = zod.object({ issue_id: zod.string().regex(/^[0-9]+$/) });
+/**
+* Issue details
+*/
+const zSentryGetIssueResponse = zSentryIssueDetails;
+const zSentryUpdateIssueBody = zIssueUpdate;
+const zSentryUpdateIssuePath = zod.object({ issue_id: zod.string().regex(/^[0-9]+$/) });
+/**
+* Issue updated
+*/
+const zSentryUpdateIssueResponse = zSentryIssue;
+const zSentryGetLatestEventPath = zod.object({ issue_id: zod.string().regex(/^[0-9]+$/) });
+/**
+* The issue's latest event
+*/
+const zSentryGetLatestEventResponse = zSentryEvent;
+/**
+* The synthetic organization
+*/
+const zSentryListOrganizationsResponse = zod.array(zSentryOrganization);
+const zSourceMapsOrgDetailsPath = zod.object({ org_slug: zod.string() });
+/**
+* Synthetic org metadata accepted by sentry-cli
+*/
+const zSourceMapsOrgDetailsResponse = zOrgDetails;
+const zSourceMapsArtifactBundleAssembleBody = zAssembleBody;
+const zSourceMapsArtifactBundleAssemblePath = zod.object({ org_slug: zod.string() });
+/**
+* Assembly job state (not_found / created / assembling / ok / error). Missing chunks are listed in missingChunks.
+*/
+const zSourceMapsArtifactBundleAssembleResponse = zAssembleResponse;
+const zSourceMapsChunkUploadCapabilityPath = zod.object({ org_slug: zod.string() });
+/**
+* Chunk upload capabilities and URL
+*/
+const zSourceMapsChunkUploadCapabilityResponse = zChunkUploadOptions;
+/**
+* One or more binary chunk files. Field names may be SHA-1 hashes (v2 protocol) or arbitrary names like 'file' (v3.x protocol).
+*/
+const zSourceMapsChunkUploadBody = zChunkUploadBody;
+const zSourceMapsChunkUploadPath = zod.object({ org_slug: zod.string() });
+const zSentryListReposPath = zod.object({ org_slug: zod.string() });
+/**
+* Connected repositories: always none
+*/
+const zSentryListReposResponse = zod.array(zod.record(zod.string(), zod.unknown()));
+const zSentryListProjectsQuery = zod.object({
+	per_page: zod.int().nullish(),
+	cursor: zod.string().nullish()
+});
+/**
+* Projects, newest first; paginated by the `Link` header
+*/
+const zSentryListProjectsResponse = zod.array(zSentryProject);
+const zSourceMapsListPath = zod.object({
+	org_slug: zod.string(),
+	project_slug: zod.string()
+});
+/**
+* List of uploaded source map files
+*/
+const zSourceMapsListResponse = zSourceMapList;
+const zSentryListIssuesPath = zod.object({
+	org_slug: zod.string(),
+	project_slug: zod.string()
+});
+const zSentryListIssuesQuery = zod.object({
+	query: zod.string().nullish(),
+	sort: zod.string().nullish(),
+	limit: zod.string().nullish(),
+	cursor: zod.string().nullish(),
+	statsPeriod: zod.string().nullish()
+});
+/**
+* Issues; paginated by the `Link` header
+*/
+const zSentryListIssuesResponse = zod.array(zSentryIssue);
+const zReleasesCreateBody = zCreateRelease;
+const zReleasesCreatePath = zod.object({
+	org_slug: zod.string(),
+	project_slug: zod.string()
+});
+/**
+* Release created
+*/
+const zReleasesCreateResponse = zReleaseResponse;
+const zReleasesFinalizeBody = zUpdateRelease;
+const zReleasesFinalizePath = zod.object({
+	org_slug: zod.string(),
+	project_slug: zod.string(),
+	version: zod.string()
+});
+/**
+* Release updated
+*/
+const zReleasesFinalizeResponse = zReleaseResponse;
+/**
+* GitHub App removed
+*/
+const zGithubDisconnectResponse = zod.void();
+/**
+* GitHub App and installations
+*/
+const zGithubStatusResponse = zGitHubStatus;
+const zGithubCallbackQuery = zod.object({
+	code: zod.string(),
+	state: zod.string()
+});
+const zGithubInstalledQuery = zod.object({ installation_id: zod.int() });
+const zGithubManifestBody = zManifestRequest;
+/**
+* Form to post to GitHub
+*/
+const zGithubManifestResponse = zManifestResponse;
+/**
+* Your GitHub username
+*/
+const zGithubGetMyLoginResponse = zGitHubLogin;
+const zGithubPutMyLoginBody = zGitHubLogin;
+/**
+* GitHub username saved
+*/
+const zGithubPutMyLoginResponse = zGitHubLogin;
+const zGithubRepositoriesQuery = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Repositories the installations reach
+*/
+const zGithubRepositoriesResponse = zod.array(zGitHubRepository);
+/**
+* GitHub event payload, signed in X-Hub-Signature-256
+*/
+const zGithubWebhookBody = zod.record(zod.string(), zod.unknown());
+/**
+* Event processed
+*/
+const zGithubWebhookResponse = zod.void();
+/**
+* List of notification channels
+*/
+const zAlertChannelsListResponse = zod.array(zAlertIntegration);
+const zAlertChannelsCreateBody = zCreateAlertIntegration;
+/**
+* Channel created
+*/
+const zAlertChannelsCreateResponse = zAlertIntegration;
+const zAlertChannelsPreviewTemplateBody = zPreviewTemplateBody;
+/**
+* Rendered body, or why it would not render
+*/
+const zAlertChannelsPreviewTemplateResponse = zPreviewTemplateResponse;
+const zAlertChannelsDeletePath = zod.object({ id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Channel deleted
+*/
+const zAlertChannelsDeleteResponse = zod.void();
+const zAlertChannelsGetPath = zod.object({ id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Channel details
+*/
+const zAlertChannelsGetResponse = zAlertIntegration;
+const zAlertChannelsUpdateBody = zUpdateAlertIntegration;
+const zAlertChannelsUpdatePath = zod.object({ id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Channel updated
+*/
+const zAlertChannelsUpdateResponse = zAlertIntegration;
+const zAlertChannelsTestBody = zTestIntegrationBody;
+const zAlertChannelsTestPath = zod.object({ id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Test notification sent
+*/
+const zAlertChannelsTestResponse = zTestChannelResponse;
+/**
+* List of invitations
+*/
+const zInvitationsListResponse = zod.array(zInvitationResponse);
+const zInvitationsCreateBody = zCreateInvitation;
+/**
+* Invitation created
+*/
+const zInvitationsCreateResponse = zInvitationResponse;
+const zInvitationsRevokePath = zod.object({ token: zod.string() });
+/**
+* Invitation revoked
+*/
+const zInvitationsRevokeResponse = zod.void();
+const zOauthGetAuthorizationQuery = zod.object({
+	response_type: zod.string(),
+	client_id: zod.string(),
+	redirect_uri: zod.string(),
+	code_challenge: zod.string(),
+	code_challenge_method: zod.string(),
+	state: zod.string().nullish(),
+	resource: zod.string().nullish()
+});
+/**
+* The verified client asking for access
+*/
+const zOauthGetAuthorizationResponse = zAuthorizationInfo;
+const zOauthDecideAuthorizationBody = zAuthorizationDecision;
+/**
+* Where to send the browser
+*/
+const zOauthDecideAuthorizationResponse = zAuthorizationRedirect;
+/**
+* Assistants connected to your account
+*/
+const zOauthListGrantsResponse = zod.array(zOAuthGrant);
+const zOauthRevokeGrantPath = zod.object({ id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Disconnected
+*/
+const zOauthRevokeGrantResponse = zod.void();
+const zProjectsListQuery = zod.object({
+	page: zod.int().gte(1).optional(),
+	per_page: zod.int().gte(1).lte(100).optional(),
+	order: zSortOrder.optional(),
+	stats_period: zod.string().nullish()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zProjectsListResponse = zod.object({
+	items: zod.array(zod.object({
+		created_at: zod.iso.datetime({ offset: true }),
+		digested_event_count: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+		dsn: zod.string(),
+		id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+		name: zod.string(),
+		platform: zod.string().nullable(),
+		rate_limit_per_hour: zod.int().nullable(),
+		rate_limit_per_minute: zod.int().nullable(),
+		rate_limited_event_count: zod.int(),
+		sentry_key: zod.uuid(),
+		slug: zod.string(),
+		stats: zProjectListStats.nullish(),
+		stored_event_count: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+		updated_at: zod.iso.datetime({ offset: true })
+	})),
+	page: zod.int(),
+	per_page: zod.int(),
+	total_count: zod.int(),
+	total_pages: zod.int()
+});
+const zProjectsCreateBody = zCreateProject;
+/**
+* Project created
+*/
+const zProjectsCreateResponse = zProjectResponse;
+const zProjectsDeletePath = zod.object({ id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Project deleted
+*/
+const zProjectsDeleteResponse = zod.void();
+const zProjectsGetPath = zod.object({ id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Project details
+*/
+const zProjectsGetResponse = zProjectResponse;
+const zProjectsUpdateBody = zUpdateProject;
+const zProjectsUpdatePath = zod.object({ id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Project updated
+*/
+const zProjectsUpdateResponse = zProjectResponse;
+const zAgentsDurationPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsDurationQuery = zod.object({
+	period_hours: zod.int().nullish(),
+	environment: zod.string().nullish(),
+	interval_hours: zod.int().gte(1).optional()
+});
+/**
+* Avg/p95 duration over time for agent runs and LLM calls
+*/
+const zAgentsDurationResponse = zod.array(zAgentDurationPoint);
+const zAgentsEnvironmentsPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Environments present in this project's AI spans
+*/
+const zAgentsEnvironmentsResponse = zod.array(zod.string());
+const zAgentsModelsTablePath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsModelsTableQuery = zod.object({
+	period_hours: zod.int().nullish(),
+	environment: zod.string().nullish()
+});
+/**
+* Per-model volume, failures, latency and token split
+*/
+const zAgentsModelsTableResponse = zod.array(zAgentModelRow);
+const zAgentsModelsCallsPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsModelsCallsQuery = zod.object({
+	period_hours: zod.int().nullish(),
+	environment: zod.string().nullish(),
+	limit: zod.int().gte(1).lte(100).optional()
+});
+/**
+* Top LLM call counts by response model
+*/
+const zAgentsModelsCallsResponse = zod.array(zGenAiBreakdownRow);
+const zAgentsModelsTokensPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsModelsTokensQuery = zod.object({
+	period_hours: zod.int().nullish(),
+	environment: zod.string().nullish(),
+	limit: zod.int().gte(1).lte(100).optional()
+});
+/**
+* Top total tokens used by response model
+*/
+const zAgentsModelsTokensResponse = zod.array(zGenAiBreakdownRow);
+const zAgentsRunsPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsRunsQuery = zod.object({
+	period_hours: zod.int().nullish(),
+	environment: zod.string().nullish(),
+	interval_hours: zod.int().gte(1).optional()
+});
+/**
+* Agent runs over time
+*/
+const zAgentsRunsResponse = zod.array(zAgentTimeseriesPoint);
+const zAgentsSummaryPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsSummaryQuery = zod.object({
+	period_hours: zod.int().nullish(),
+	environment: zod.string().nullish()
+});
+/**
+* Headline totals for the selected window
+*/
+const zAgentsSummaryResponse = zAgentSummary;
+const zAgentsToolsPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsToolsQuery = zod.object({
+	period_hours: zod.int().nullish(),
+	environment: zod.string().nullish(),
+	limit: zod.int().gte(1).lte(100).optional()
+});
+/**
+* Top tool call counts by tool name
+*/
+const zAgentsToolsResponse = zod.array(zGenAiBreakdownRow);
+const zAgentsToolsTablePath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsToolsTableQuery = zod.object({
+	period_hours: zod.int().nullish(),
+	environment: zod.string().nullish()
+});
+/**
+* Per-tool call volume, failures and latency
+*/
+const zAgentsToolsTableResponse = zod.array(zAgentToolRow);
+const zAgentsTracesPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsTracesQuery = zod.object({
+	period_hours: zod.int().nullish(),
+	environment: zod.string().nullish(),
+	page: zod.int().gte(1).optional(),
+	per_page: zod.int().gte(1).lte(100).optional()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zAgentsTracesResponse = zod.object({
+	items: zod.array(zod.object({
+		agent_names: zod.array(zod.string()),
+		duration_ms: zod.number().nullable(),
+		error_count: zod.int(),
+		llm_call_count: zod.int(),
+		started_at: zod.iso.datetime({ offset: true }),
+		tool_call_count: zod.int(),
+		total_tokens: zod.number(),
+		trace_id: zod.string()
+	})),
+	page: zod.int(),
+	per_page: zod.int(),
+	total_count: zod.int(),
+	total_pages: zod.int()
+});
+const zAlertRulesListHistoryPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAlertRulesListHistoryQuery = zod.object({ limit: zod.int().optional() });
+/**
+* Alert history
+*/
+const zAlertRulesListHistoryResponse = zod.array(zAlertHistory);
+const zAlertRulesListPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* List of alert rules
+*/
+const zAlertRulesListResponse = zod.array(zAlertRuleResponse);
+const zAlertRulesCreateBody = zCreateAlertRule;
+const zAlertRulesCreatePath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Alert rule created
+*/
+const zAlertRulesCreateResponse = zAlertRuleResponse;
+const zAlertRulesDeletePath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	rule_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+});
+/**
+* Alert rule deleted
+*/
+const zAlertRulesDeleteResponse = zod.void();
+const zAlertRulesGetPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	rule_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+});
+/**
+* Alert rule details
+*/
+const zAlertRulesGetResponse = zAlertRuleResponse;
+const zAlertRulesUpdateBody = zUpdateAlertRule;
+const zAlertRulesUpdatePath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	rule_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+});
+/**
+* Alert rule updated
+*/
+const zAlertRulesUpdateResponse = zAlertRuleResponse;
+const zEventsGetBySentryIdPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	event_id: zod.string()
+});
+/**
+* Full event detail, including its issue ID
+*/
+const zEventsGetBySentryIdResponse = zEventDetailResponse;
+const zStatsGetEventTimeseriesPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zStatsGetEventTimeseriesQuery = zod.object({
+	period: zod.string().optional(),
+	interval: zod.int().optional()
+});
+/**
+* Time-bucketed error-event volume by severity
+*/
+const zStatsGetEventTimeseriesResponse = zod.array(zEventTimeseriesPoint);
+const zGithubDeleteProjectRepositoryPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Repository removed
+*/
+const zGithubDeleteProjectRepositoryResponse = zod.void();
+const zGithubGetProjectRepositoryPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* The project's repository, if any
+*/
+const zGithubGetProjectRepositoryResponse = zProjectRepository.nullable();
+const zGithubPutProjectRepositoryBody = zUpdateProjectRepository;
+const zGithubPutProjectRepositoryPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Repository saved
+*/
+const zGithubPutProjectRepositoryResponse = zProjectRepository;
+const zGithubSyncCodeownersPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* CODEOWNERS synced
+*/
+const zGithubSyncCodeownersResponse = zProjectRepository;
+const zIssuesBulkDeleteBody = zBulkDeleteIssues;
+const zIssuesBulkDeletePath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Number of issues deleted
+*/
+const zIssuesBulkDeleteResponse = zBulkDeleteResponse;
+const zIssuesListPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zIssuesListQuery = zod.object({
+	page: zod.int().gte(1).optional(),
+	per_page: zod.int().gte(1).lte(100).optional(),
+	sort: zIssueSort.optional(),
+	order: zSortOrder.optional(),
+	filter: zIssueFilter.optional(),
+	q: zod.string().nullish()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zIssuesListResponse = zod.object({
+	items: zod.array(zod.object({
+		assigned_to: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+		assignee_type: zod.string().nullable(),
+		culprit: zod.string(),
+		event_count: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+		first_release: zod.string(),
+		first_seen: zod.iso.datetime({ offset: true }),
+		has_seen: zod.boolean().nullish(),
+		id: zod.uuid(),
+		is_bookmarked: zod.boolean().nullish(),
+		is_muted: zod.boolean(),
+		is_resolved: zod.boolean(),
+		is_subscribed: zod.boolean().nullish(),
+		issue_category: zod.string(),
+		issue_type: zod.string(),
+		last_release: zod.string(),
+		last_seen: zod.iso.datetime({ offset: true }),
+		level: zod.string().nullable(),
+		logger: zod.string(),
+		platform: zod.string().nullable(),
+		priority: zIssuePriority.nullable(),
+		project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+		short_id: zod.string(),
+		status: zIssueStatus,
+		status_details: zod.record(zod.string(), zod.unknown()),
+		substatus: zod.string().nullable(),
+		title: zod.string(),
+		trend: zod.array(zod.int()).nullish(),
+		user_count: zod.int().nullish(),
+		user_report_count: zod.int().nullish(),
+		value: zod.string()
+	})),
+	page: zod.int(),
+	per_page: zod.int(),
+	total_count: zod.int(),
+	total_pages: zod.int()
+});
+const zIssuesBulkUpdateBody = zBulkUpdateIssues;
+const zIssuesBulkUpdatePath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Number of issues updated
+*/
+const zIssuesBulkUpdateResponse = zBulkUpdateResponse;
+const zIssuesDeletePath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+/**
+* Issue deleted
+*/
+const zIssuesDeleteResponse = zod.void();
+const zIssuesGetPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+/**
+* Issue details
+*/
+const zIssuesGetResponse = zIssueResponse;
+const zIssuesUpdateBody = zUpdateIssueState;
+const zIssuesUpdatePath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+/**
+* Issue updated
+*/
+const zIssuesUpdateResponse = zIssueResponse;
+const zIssuesGetActivityPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+/**
+* Activity log (status changes, comments, …)
+*/
+const zIssuesGetActivityResponse = zod.array(zActivityEntry);
+const zIssuesGetAggregatesPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+/**
+* Unique user count and top tags
+*/
+const zIssuesGetAggregatesResponse = zIssueAggregates;
+const zIssuesSetBookmarkBody = zToggleRequest;
+const zIssuesSetBookmarkPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+/**
+* Updated bookmark state
+*/
+const zIssuesSetBookmarkResponse = zBookmarkResponse;
+const zIssuesCreateCommentBody = zCommentRequest;
+const zIssuesCreateCommentPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+/**
+* Comment added
+*/
+const zIssuesCreateCommentResponse = zActivityEntry;
+const zEventsListPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+const zEventsListQuery = zod.object({
+	order: zSortOrder.optional(),
+	cursor: zod.string().nullish()
+});
+/**
+* Paginated response wrapper (cursor-based)
+*/
+const zEventsListResponse = zod.object({
+	has_more: zod.boolean(),
+	items: zod.array(zod.object({
+		environment: zod.string(),
+		event_id: zod.string(),
+		event_type: zod.string(),
+		id: zod.uuid(),
+		issue_id: zod.uuid().nullable(),
+		level: zod.string(),
+		platform: zod.string(),
+		release: zod.string(),
+		timestamp: zod.iso.datetime({ offset: true }),
+		title: zod.string()
+	})),
+	next_cursor: zod.string().nullish()
+});
+const zEventsGetPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid(),
+	event_id: zod.uuid()
+});
+/**
+* Full event detail
+*/
+const zEventsGetResponse = zEventDetailResponse;
+const zGithubIssuePath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+/**
+* Links, suspect commits and owners
+*/
+const zGithubIssueResponse = zIssueGitHub;
+const zGithubCreateIssueBody = zCreateGitHubIssue;
+const zGithubCreateIssuePath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+/**
+* GitHub issue created and linked
+*/
+const zGithubCreateIssueResponse = zIssueLink;
+const zGithubLinkIssueBody = zLinkGitHubIssue;
+const zGithubLinkIssuePath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+/**
+* GitHub issue linked
+*/
+const zGithubLinkIssueResponse = zIssueLink;
+const zGithubUnlinkIssuePath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid(),
+	link_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+});
+/**
+* Link removed
+*/
+const zGithubUnlinkIssueResponse = zod.void();
+const zIssuesGetHashesPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+/**
+* Grouping hashes mapped to the issue
+*/
+const zIssuesGetHashesResponse = zod.array(zGrouping);
+const zIssuesMarkSeenPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+/**
+* Issue marked as seen
+*/
+const zIssuesMarkSeenResponse = zSeenResponse;
+const zIssuesGetStatsPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+const zIssuesGetStatsQuery = zod.object({ window: zIssueStatsWindow.optional() });
+/**
+* Zero-filled event-count timeseries
+*/
+const zIssuesGetStatsResponse = zIssueStatsResponse;
+const zIssuesSetSubscriptionBody = zToggleRequest;
+const zIssuesSetSubscriptionPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+/**
+* Updated subscription state
+*/
+const zIssuesSetSubscriptionResponse = zSubscriptionResponse;
+const zIssuesGetTagValuesPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid(),
+	key: zod.string()
+});
+/**
+* Distinct values for the tag key, one entry per value (Sentry-compatible: a bare list, not wrapped)
+*/
+const zIssuesGetTagValuesResponse = zod.array(zIssueTagValue);
+const zIssuesListUserReportsPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+/**
+* User feedback reports for the issue
+*/
+const zIssuesListUserReportsResponse = zod.array(zUserReport);
+const zIssuesCreateUserReportBody = zUserReportRequest;
+const zIssuesCreateUserReportPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: zod.uuid()
+});
+/**
+* User feedback attached
+*/
+const zIssuesCreateUserReportResponse = zUserReport;
+const zLogsListPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zLogsListQuery = zod.object({
+	page: zod.int().gte(1).optional(),
+	per_page: zod.int().gte(1).lte(100).optional(),
+	level: zod.string().nullish(),
+	trace_id: zod.string().nullish()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zLogsListResponse = zod.object({
+	items: zod.array(zod.object({
+		attributes: zod.record(zod.string(), zod.unknown()),
+		body: zod.string(),
+		id: zod.uuid(),
+		ingested_at: zod.iso.datetime({ offset: true }),
+		level: zod.string(),
+		severity_number: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+		span_id: zod.string().nullable(),
+		timestamp: zod.iso.datetime({ offset: true }),
+		trace_id: zod.string().nullable()
+	})),
+	page: zod.int(),
+	per_page: zod.int(),
+	total_count: zod.int(),
+	total_pages: zod.int()
+});
+const zMembersListPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* List of project members
+*/
+const zMembersListResponse = zod.array(zProjectMemberResponse);
+const zMembersUpsertBody = zUpsertProjectMember;
+const zMembersUpsertPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Member added or updated
+*/
+const zMembersUpsertResponse = zProjectMember;
+const zMembersRemovePath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	user_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+});
+/**
+* Member removed
+*/
+const zMembersRemoveResponse = zod.void();
+const zMonitorsListPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Every cron monitor of the project, with its environments and recent check-ins
+*/
+const zMonitorsListResponse = zod.array(zMonitorResponse);
+const zMonitorsCreateBody = zCreateMonitor;
+const zMonitorsCreatePath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Created
+*/
+const zMonitorsCreateResponse = zMonitorResponse;
+const zMonitorsDeletePath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	slug: zod.string()
+});
+/**
+* Deleted with its check-ins; its issues stay
+*/
+const zMonitorsDeleteResponse = zod.void();
+const zMonitorsGetPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	slug: zod.string()
+});
+/**
+* The monitor
+*/
+const zMonitorsGetResponse = zMonitorResponse;
+const zMonitorsUpdateBody = zUpdateMonitor;
+const zMonitorsUpdatePath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	slug: zod.string()
+});
+/**
+* Updated
+*/
+const zMonitorsUpdateResponse = zMonitorResponse;
+const zMonitorsListCheckinsPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	slug: zod.string()
+});
+const zMonitorsListCheckinsQuery = zod.object({
+	page: zod.int().optional(),
+	per_page: zod.int().optional(),
+	environment: zod.string().nullish()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zMonitorsListCheckinsResponse = zod.object({
+	items: zod.array(zod.object({
+		date_added: zod.iso.datetime({ offset: true }),
+		date_updated: zod.iso.datetime({ offset: true }),
+		duration_ms: zod.int().nullable(),
+		environment: zod.string(),
+		expected_time: zod.iso.datetime({ offset: true }).nullable(),
+		id: zod.uuid(),
+		status: zCheckInStatus
+	})),
+	page: zod.int(),
+	per_page: zod.int(),
+	total_count: zod.int(),
+	total_pages: zod.int()
+});
+const zReleasesNewIssuesPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	release: zod.string()
+});
+const zReleasesNewIssuesQuery = zod.object({ limit: zod.int().optional() });
+/**
+* Issues first seen in this release, most recent first
+*/
+const zReleasesNewIssuesResponse = zod.array(zIssueResponse);
+const zSessionsGetStatsPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zSessionsGetStatsQuery = zod.object({
+	period: zod.string().nullish(),
+	release: zod.string().nullish(),
+	page: zod.int().gte(1).optional(),
+	per_page: zod.int().gte(1).lte(100).optional()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zSessionsGetStatsResponse = zod.object({
+	items: zod.array(zod.object({
+		abnormal: zod.int(),
+		crash_free_sessions_rate: zod.number().nullable(),
+		crash_free_users_rate: zod.number().nullable(),
+		crashed: zod.int(),
+		environment: zod.string(),
+		errored: zod.int(),
+		healthy: zod.int(),
+		release: zod.string(),
+		total: zod.int()
+	})),
+	page: zod.int(),
+	per_page: zod.int(),
+	total_count: zod.int(),
+	total_pages: zod.int()
+});
+const zSessionsGetSummaryPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zSessionsGetSummaryQuery = zod.object({ period: zod.string().optional() });
+/**
+* Project-wide session health summary
+*/
+const zSessionsGetSummaryResponse = zSessionSummary;
+const zSessionsGetTimeseriesPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zSessionsGetTimeseriesQuery = zod.object({
+	period: zod.string().optional(),
+	interval: zod.int().optional()
+});
+/**
+* Time-bucketed session trend, project-wide
+*/
+const zSessionsGetTimeseriesResponse = zod.array(zSessionTimeseriesPoint);
+const zSpansListPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zSpansListQuery = zod.object({
+	page: zod.int().gte(1).optional(),
+	per_page: zod.int().gte(1).lte(100).optional(),
+	op: zod.string().nullish(),
+	status: zod.string().nullish(),
+	trace_id: zod.string().nullish(),
+	operation_type: zod.string().nullish()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zSpansListResponse = zod.object({
+	items: zod.array(zod.object({
+		description: zod.string().nullable(),
+		duration_ms: zod.number().nullable(),
+		environment: zod.string().nullable(),
+		exclusive_time_ms: zod.number().nullable(),
+		gen_ai_agent_name: zod.string().nullable(),
+		gen_ai_conversation_id: zod.string().nullable(),
+		gen_ai_operation_type: zod.string().nullable(),
+		gen_ai_request_model: zod.string().nullable(),
+		gen_ai_response_model: zod.string().nullable(),
+		gen_ai_tool_name: zod.string().nullable(),
+		gen_ai_usage_input_tokens: zod.number().nullable(),
+		gen_ai_usage_output_tokens: zod.number().nullable(),
+		gen_ai_usage_total_tokens: zod.number().nullable(),
+		id: zod.uuid(),
+		is_segment: zod.boolean(),
+		op: zod.string().nullable(),
+		parent_span_id: zod.string().nullable(),
+		platform: zod.string().nullable(),
+		release: zod.string().nullable(),
+		segment_id: zod.string().nullable(),
+		span_id: zod.string().nullable(),
+		start_timestamp: zod.iso.datetime({ offset: true }).nullable(),
+		status: zod.string().nullable(),
+		timestamp: zod.iso.datetime({ offset: true }).nullable(),
+		trace_id: zod.string().nullable(),
+		transaction_id: zod.uuid().nullable()
+	})),
+	page: zod.int(),
+	per_page: zod.int(),
+	total_count: zod.int(),
+	total_pages: zod.int()
+});
+const zSpansGetPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	span_id: zod.uuid()
+});
+/**
+* Span with its full attribute bag
+*/
+const zSpansGetResponse = zSpanDetailResponse;
+const zStatsGetSummaryPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zStatsGetSummaryQuery = zod.object({ period: zod.string().optional() });
+/**
+* Project counters with previous-period comparison
+*/
+const zStatsGetSummaryResponse = zProjectStatsSummary;
+const zTransactionsListPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zTransactionsListQuery = zod.object({
+	page: zod.int().gte(1).optional(),
+	per_page: zod.int().gte(1).lte(100).optional(),
+	name: zod.string().nullish(),
+	op: zod.string().nullish(),
+	status: zod.string().nullish(),
+	environment: zod.string().nullish(),
+	release: zod.string().nullish()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zTransactionsListResponse = zod.object({
+	items: zod.array(zod.object({
+		duration_ms: zod.number().nullable(),
+		environment: zod.string(),
+		event_id: zod.string(),
+		id: zod.uuid(),
+		ingested_at: zod.iso.datetime({ offset: true }),
+		platform: zod.string(),
+		release: zod.string(),
+		start_timestamp: zod.iso.datetime({ offset: true }).nullable(),
+		timestamp: zod.iso.datetime({ offset: true }),
+		transaction_name: zod.string()
+	})),
+	page: zod.int(),
+	per_page: zod.int(),
+	total_count: zod.int(),
+	total_pages: zod.int()
+});
+const zTransactionsGetStatsPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zTransactionsGetStatsQuery = zod.object({
+	page: zod.int().gte(1).optional(),
+	per_page: zod.int().gte(1).lte(100).optional()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zTransactionsGetStatsResponse = zod.object({
+	items: zod.array(zod.object({
+		count: zod.int(),
+		failure_rate: zod.number(),
+		op: zod.string().nullable(),
+		p50_ms: zod.number(),
+		p95_ms: zod.number(),
+		p99_ms: zod.number(),
+		transaction_name: zod.string()
+	})),
+	page: zod.int(),
+	per_page: zod.int(),
+	total_count: zod.int(),
+	total_pages: zod.int()
+});
+const zTransactionsGetStatGroupPath = zod.object({ project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zTransactionsGetStatGroupQuery = zod.object({
+	name: zod.string(),
+	op: zod.string().nullish()
+});
+/**
+* Aggregate stats for one (transaction, op) group
+*/
+const zTransactionsGetStatGroupResponse = zTransactionStatsResponse;
+const zTransactionsGetPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	transaction_id: zod.uuid()
+});
+/**
+* Full transaction detail
+*/
+const zTransactionsGetResponse = zTransactionDetailResponse;
+const zTransactionsGetSpansPath = zod.object({
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	transaction_id: zod.uuid()
+});
+/**
+* Indexed spans for the transaction (waterfall order)
+*/
+const zTransactionsGetSpansResponse = zod.array(zod.object({
+	description: zod.string().nullable(),
+	duration_ms: zod.number().nullable(),
+	environment: zod.string().nullable(),
+	exclusive_time_ms: zod.number().nullable(),
+	gen_ai_agent_name: zod.string().nullable(),
+	gen_ai_conversation_id: zod.string().nullable(),
+	gen_ai_operation_type: zod.string().nullable(),
+	gen_ai_request_model: zod.string().nullable(),
+	gen_ai_response_model: zod.string().nullable(),
+	gen_ai_tool_name: zod.string().nullable(),
+	gen_ai_usage_input_tokens: zod.number().nullable(),
+	gen_ai_usage_output_tokens: zod.number().nullable(),
+	gen_ai_usage_total_tokens: zod.number().nullable(),
+	id: zod.uuid(),
+	is_segment: zod.boolean(),
+	op: zod.string().nullable(),
+	parent_span_id: zod.string().nullable(),
+	platform: zod.string().nullable(),
+	release: zod.string().nullable(),
+	segment_id: zod.string().nullable(),
+	span_id: zod.string().nullable(),
+	start_timestamp: zod.iso.datetime({ offset: true }).nullable(),
+	status: zod.string().nullable(),
+	timestamp: zod.iso.datetime({ offset: true }).nullable(),
+	trace_id: zod.string().nullable(),
+	transaction_id: zod.uuid().nullable()
+}));
+/**
+* The server's per-project limits
+*/
+const zProjectsGetRateLimitsResponse = zRateLimitsResponse;
+const zSchedulesPreviewBody = zPreviewSchedule;
+/**
+* The next five runs
+*/
+const zSchedulesPreviewResponse = zSchedulePreview;
+/**
+* Whether the MCP endpoint is on, and its URL
+*/
+const zSettingsGetMcpResponse = zMcpStatus;
+const zSettingsUpdateMcpBody = zMcpSettings;
+/**
+* The MCP endpoint's new state, and its URL
+*/
+const zSettingsUpdateMcpResponse = zMcpStatus;
+/**
+* How long ago each project's data arrived, per kind
+*/
+const zStorageGetAgeResponse = zStorageAge;
+const zStorageExecuteCleanupBody = zCleanupRequest;
+/**
+* Cleanup started in the background; poll its status
+*/
+const zStorageExecuteCleanupResponse = zCleanupStatus;
+const zStoragePreviewCleanupBody = zCleanupRequest;
+/**
+* Dry-run: rows a cleanup would remove
+*/
+const zStoragePreviewCleanupResponse = zCleanupCounts;
+/**
+* The current or last cleanup and the rows it removed
+*/
+const zStorageGetCleanupStatusResponse = zCleanupStatus;
+/**
+* Per-project storage breakdown
+*/
+const zStorageGetProjectsResponse = zod.array(zod.object({
+	estimated_bytes: zod.int(),
+	events_bytes: zod.int(),
+	events_count: zod.int(),
+	logs_bytes: zod.int(),
+	logs_count: zod.int(),
+	project_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	project_name: zod.string(),
+	source_maps_count: zod.int(),
+	spans_count: zod.int(),
+	transactions_bytes: zod.int(),
+	transactions_count: zod.int()
+}));
+/**
+* Retention settings, next cleanup and last cleanup
+*/
+const zStorageGetRetentionResponse = zRetentionResponse;
+const zStorageUpdateRetentionBody = zRetentionSettings;
+/**
+* Saved; the new schedule applies within a minute
+*/
+const zStorageUpdateRetentionResponse = zRetentionResponse;
+const zStoragePreviewRetentionBody = zRetentionSettings;
+/**
+* Dry-run: rows enforcing these settings now would remove
+*/
+const zStoragePreviewRetentionResponse = zCleanupCounts;
+/**
+* Cleanup started in the background; poll its status
+*/
+const zStorageRunRetentionResponse = zCleanupStatus;
+/**
+* Orphaned source maps removed
+*/
+const zStorageGcSourceMapsResponse = zSourceMapGcResult;
+/**
+* Dry-run: orphaned source maps a GC would remove
+*/
+const zStoragePreviewSourceMapGcResponse = zSourceMapGcResult;
+/**
+* Instance-wide storage summary
+*/
+const zStorageGetSummaryResponse = zStorageSummary;
+/**
+* List of team members
+*/
+const zTeamListResponse = zod.array(zTeamMemberResponse);
+const zTeamDeleteUserPath = zod.object({ user_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* User deleted
+*/
+const zTeamDeleteUserResponse = zod.void();
+const zTeamUpdateRoleBody = zUpdateUserRole;
+const zTeamUpdateRolePath = zod.object({ user_id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Role updated
+*/
+const zTeamUpdateRoleResponse = zod.void();
+/**
+* What the next heartbeat would carry
+*/
+const zTelemetryPreviewResponse = zTelemetryPreview;
+/**
+* List of tokens (masked)
+*/
+const zTokensListResponse = zod.array(zAuthTokenResponse);
+const zTokensCreateBody = zCreateAuthToken;
+/**
+* Token created (full token shown once)
+*/
+const zTokensCreateResponse = zAuthTokenCreatedResponse;
+const zTokensDeletePath = zod.object({ id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Token revoked
+*/
+const zTokensDeleteResponse = zod.void();
+const zTokensGetPath = zod.object({ id: zod.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Token details (full token value)
+*/
+const zTokensGetResponse = zAuthTokenCreatedResponse;
+const zAuthAcceptInvitationBody = zAcceptInvitation;
+/**
+* Invitation accepted, user created and logged in
+*/
+const zAuthAcceptInvitationResponse = zAuthResponse;
+const zAuthGetInvitationPath = zod.object({ token: zod.string() });
+/**
+* Invitation info
+*/
+const zAuthGetInvitationResponse = zInvitationInfoResponse;
+const zAuthLoginBody = zLoginRequest;
+/**
+* Logged in
+*/
+const zAuthLoginResponse = zAuthResponse;
+/**
+* Logged out
+*/
+const zAuthLogoutResponse = zod.void();
+/**
+* Current user
+*/
+const zAuthGetCurrentUserResponse = zUserResponse;
+const zAuthUpdateCurrentUserBody = zUpdatePreferencesRequest;
+/**
+* Updated user
+*/
+const zAuthUpdateCurrentUserResponse = zUserResponse;
+const zAuthChangePasswordBody = zChangePasswordRequest;
+/**
+* Password changed
+*/
+const zAuthChangePasswordResponse = zod.void();
+const zAuthRegisterBody = zCreateUserRequest;
+const zAuthSsoCallbackQuery = zod.object({
+	code: zod.string().nullish(),
+	state: zod.string().nullish(),
+	error: zod.string().nullish()
+});
+/**
+* SSO login completed
+*/
+const zAuthSsoCallbackResponse = zAuthResponse;
+/**
+* Public SSO configuration
+*/
+const zAuthSsoConfigResponse = zSsoConfigResponse;
+/**
+* The account waiting for its password
+*/
+const zAuthSsoLinkResponse = zSsoLinkResponse;
+const zAuthConfirmSsoLinkBody = zConfirmSsoLinkRequest;
+/**
+* Identity linked and signed in
+*/
+const zAuthConfirmSsoLinkResponse = zAuthResponse;
+/**
+* OIDC authorization URL
+*/
+const zAuthSsoStartResponse = zSsoStartResponse;
+/**
+* Server is alive
+*/
+const zHealthLivenessResponse = zLivenessResponse;
+/**
+* Service is ready
+*/
+const zHealthReadinessResponse = zReadinessResponse;
+/**
+* Server version info
+*/
+const zHealthVersionResponse = zVersionResponse;
+const zSentryOpenIssuePath = zod.object({
+	org_slug: zod.string(),
+	project_slug: zod.string(),
+	issue_id: zod.string().regex(/^[0-9]+$/)
+});
+//#endregion
+exports.zAcceptInvitation = zAcceptInvitation;
+exports.zActivityEntry = zActivityEntry;
+exports.zAgentDurationPoint = zAgentDurationPoint;
+exports.zAgentModelRow = zAgentModelRow;
+exports.zAgentSummary = zAgentSummary;
+exports.zAgentTimeseriesPoint = zAgentTimeseriesPoint;
+exports.zAgentToolRow = zAgentToolRow;
+exports.zAgentsDurationPath = zAgentsDurationPath;
+exports.zAgentsDurationQuery = zAgentsDurationQuery;
+exports.zAgentsDurationResponse = zAgentsDurationResponse;
+exports.zAgentsEnvironmentsPath = zAgentsEnvironmentsPath;
+exports.zAgentsEnvironmentsResponse = zAgentsEnvironmentsResponse;
+exports.zAgentsModelsCallsPath = zAgentsModelsCallsPath;
+exports.zAgentsModelsCallsQuery = zAgentsModelsCallsQuery;
+exports.zAgentsModelsCallsResponse = zAgentsModelsCallsResponse;
+exports.zAgentsModelsTablePath = zAgentsModelsTablePath;
+exports.zAgentsModelsTableQuery = zAgentsModelsTableQuery;
+exports.zAgentsModelsTableResponse = zAgentsModelsTableResponse;
+exports.zAgentsModelsTokensPath = zAgentsModelsTokensPath;
+exports.zAgentsModelsTokensQuery = zAgentsModelsTokensQuery;
+exports.zAgentsModelsTokensResponse = zAgentsModelsTokensResponse;
+exports.zAgentsRunsPath = zAgentsRunsPath;
+exports.zAgentsRunsQuery = zAgentsRunsQuery;
+exports.zAgentsRunsResponse = zAgentsRunsResponse;
+exports.zAgentsSummaryPath = zAgentsSummaryPath;
+exports.zAgentsSummaryQuery = zAgentsSummaryQuery;
+exports.zAgentsSummaryResponse = zAgentsSummaryResponse;
+exports.zAgentsToolsPath = zAgentsToolsPath;
+exports.zAgentsToolsQuery = zAgentsToolsQuery;
+exports.zAgentsToolsResponse = zAgentsToolsResponse;
+exports.zAgentsToolsTablePath = zAgentsToolsTablePath;
+exports.zAgentsToolsTableQuery = zAgentsToolsTableQuery;
+exports.zAgentsToolsTableResponse = zAgentsToolsTableResponse;
+exports.zAgentsTracesPath = zAgentsTracesPath;
+exports.zAgentsTracesQuery = zAgentsTracesQuery;
+exports.zAgentsTracesResponse = zAgentsTracesResponse;
+exports.zAlertChannelsCreateBody = zAlertChannelsCreateBody;
+exports.zAlertChannelsCreateResponse = zAlertChannelsCreateResponse;
+exports.zAlertChannelsDeletePath = zAlertChannelsDeletePath;
+exports.zAlertChannelsDeleteResponse = zAlertChannelsDeleteResponse;
+exports.zAlertChannelsGetPath = zAlertChannelsGetPath;
+exports.zAlertChannelsGetResponse = zAlertChannelsGetResponse;
+exports.zAlertChannelsListResponse = zAlertChannelsListResponse;
+exports.zAlertChannelsPreviewTemplateBody = zAlertChannelsPreviewTemplateBody;
+exports.zAlertChannelsPreviewTemplateResponse = zAlertChannelsPreviewTemplateResponse;
+exports.zAlertChannelsTestBody = zAlertChannelsTestBody;
+exports.zAlertChannelsTestPath = zAlertChannelsTestPath;
+exports.zAlertChannelsTestResponse = zAlertChannelsTestResponse;
+exports.zAlertChannelsUpdateBody = zAlertChannelsUpdateBody;
+exports.zAlertChannelsUpdatePath = zAlertChannelsUpdatePath;
+exports.zAlertChannelsUpdateResponse = zAlertChannelsUpdateResponse;
+exports.zAlertHistory = zAlertHistory;
+exports.zAlertIntegration = zAlertIntegration;
+exports.zAlertRuleChannelInput = zAlertRuleChannelInput;
+exports.zAlertRuleResponse = zAlertRuleResponse;
+exports.zAlertRulesCreateBody = zAlertRulesCreateBody;
+exports.zAlertRulesCreatePath = zAlertRulesCreatePath;
+exports.zAlertRulesCreateResponse = zAlertRulesCreateResponse;
+exports.zAlertRulesDeletePath = zAlertRulesDeletePath;
+exports.zAlertRulesDeleteResponse = zAlertRulesDeleteResponse;
+exports.zAlertRulesGetPath = zAlertRulesGetPath;
+exports.zAlertRulesGetResponse = zAlertRulesGetResponse;
+exports.zAlertRulesListHistoryPath = zAlertRulesListHistoryPath;
+exports.zAlertRulesListHistoryQuery = zAlertRulesListHistoryQuery;
+exports.zAlertRulesListHistoryResponse = zAlertRulesListHistoryResponse;
+exports.zAlertRulesListPath = zAlertRulesListPath;
+exports.zAlertRulesListResponse = zAlertRulesListResponse;
+exports.zAlertRulesUpdateBody = zAlertRulesUpdateBody;
+exports.zAlertRulesUpdatePath = zAlertRulesUpdatePath;
+exports.zAlertRulesUpdateResponse = zAlertRulesUpdateResponse;
+exports.zAlertStatus = zAlertStatus;
+exports.zAlertType = zAlertType;
+exports.zAssembleBody = zAssembleBody;
+exports.zAssembleResponse = zAssembleResponse;
+exports.zAuthAcceptInvitationBody = zAuthAcceptInvitationBody;
+exports.zAuthAcceptInvitationResponse = zAuthAcceptInvitationResponse;
+exports.zAuthChangePasswordBody = zAuthChangePasswordBody;
+exports.zAuthChangePasswordResponse = zAuthChangePasswordResponse;
+exports.zAuthConfirmSsoLinkBody = zAuthConfirmSsoLinkBody;
+exports.zAuthConfirmSsoLinkResponse = zAuthConfirmSsoLinkResponse;
+exports.zAuthGetCurrentUserResponse = zAuthGetCurrentUserResponse;
+exports.zAuthGetInvitationPath = zAuthGetInvitationPath;
+exports.zAuthGetInvitationResponse = zAuthGetInvitationResponse;
+exports.zAuthLoginBody = zAuthLoginBody;
+exports.zAuthLoginResponse = zAuthLoginResponse;
+exports.zAuthLogoutResponse = zAuthLogoutResponse;
+exports.zAuthRegisterBody = zAuthRegisterBody;
+exports.zAuthResponse = zAuthResponse;
+exports.zAuthSsoCallbackQuery = zAuthSsoCallbackQuery;
+exports.zAuthSsoCallbackResponse = zAuthSsoCallbackResponse;
+exports.zAuthSsoConfigResponse = zAuthSsoConfigResponse;
+exports.zAuthSsoLinkResponse = zAuthSsoLinkResponse;
+exports.zAuthSsoStartResponse = zAuthSsoStartResponse;
+exports.zAuthTokenCreatedResponse = zAuthTokenCreatedResponse;
+exports.zAuthTokenResponse = zAuthTokenResponse;
+exports.zAuthUpdateCurrentUserBody = zAuthUpdateCurrentUserBody;
+exports.zAuthUpdateCurrentUserResponse = zAuthUpdateCurrentUserResponse;
+exports.zAuthorizationDecision = zAuthorizationDecision;
+exports.zAuthorizationInfo = zAuthorizationInfo;
+exports.zAuthorizationRedirect = zAuthorizationRedirect;
+exports.zAuthorizationRequest = zAuthorizationRequest;
+exports.zBookmarkResponse = zBookmarkResponse;
+exports.zBulkDeleteIssues = zBulkDeleteIssues;
+exports.zBulkDeleteResponse = zBulkDeleteResponse;
+exports.zBulkUpdateIssues = zBulkUpdateIssues;
+exports.zBulkUpdateResponse = zBulkUpdateResponse;
+exports.zChangePasswordRequest = zChangePasswordRequest;
+exports.zCheckInResponse = zCheckInResponse;
+exports.zCheckInStatus = zCheckInStatus;
+exports.zChunkUploadBody = zChunkUploadBody;
+exports.zChunkUploadOptions = zChunkUploadOptions;
+exports.zCleanupCounts = zCleanupCounts;
+exports.zCleanupFrequency = zCleanupFrequency;
+exports.zCleanupRequest = zCleanupRequest;
+exports.zCleanupState = zCleanupState;
+exports.zCleanupStatus = zCleanupStatus;
+exports.zCodeMapping = zCodeMapping;
+exports.zCommentRequest = zCommentRequest;
+exports.zConfirmSsoLinkRequest = zConfirmSsoLinkRequest;
+exports.zCreateAlertIntegration = zCreateAlertIntegration;
+exports.zCreateAlertRule = zCreateAlertRule;
+exports.zCreateAuthToken = zCreateAuthToken;
+exports.zCreateGitHubIssue = zCreateGitHubIssue;
+exports.zCreateInvitation = zCreateInvitation;
+exports.zCreateMonitor = zCreateMonitor;
+exports.zCreateProject = zCreateProject;
+exports.zCreateRelease = zCreateRelease;
+exports.zCreateUserRequest = zCreateUserRequest;
+exports.zErrorDetail = zErrorDetail;
+exports.zEventDetailResponse = zEventDetailResponse;
+exports.zEventTimeseriesPoint = zEventTimeseriesPoint;
+exports.zEventsGetBySentryIdPath = zEventsGetBySentryIdPath;
+exports.zEventsGetBySentryIdResponse = zEventsGetBySentryIdResponse;
+exports.zEventsGetPath = zEventsGetPath;
+exports.zEventsGetResponse = zEventsGetResponse;
+exports.zEventsListPath = zEventsListPath;
+exports.zEventsListQuery = zEventsListQuery;
+exports.zEventsListResponse = zEventsListResponse;
+exports.zFieldError = zFieldError;
+exports.zFieldErrorCode = zFieldErrorCode;
+exports.zGenAiBreakdownRow = zGenAiBreakdownRow;
+exports.zGitHubAppInfo = zGitHubAppInfo;
+exports.zGitHubInstallation = zGitHubInstallation;
+exports.zGitHubLogin = zGitHubLogin;
+exports.zGitHubRepository = zGitHubRepository;
+exports.zGitHubStatus = zGitHubStatus;
+exports.zGithubCallbackQuery = zGithubCallbackQuery;
+exports.zGithubCreateIssueBody = zGithubCreateIssueBody;
+exports.zGithubCreateIssuePath = zGithubCreateIssuePath;
+exports.zGithubCreateIssueResponse = zGithubCreateIssueResponse;
+exports.zGithubDeleteProjectRepositoryPath = zGithubDeleteProjectRepositoryPath;
+exports.zGithubDeleteProjectRepositoryResponse = zGithubDeleteProjectRepositoryResponse;
+exports.zGithubDisconnectResponse = zGithubDisconnectResponse;
+exports.zGithubGetMyLoginResponse = zGithubGetMyLoginResponse;
+exports.zGithubGetProjectRepositoryPath = zGithubGetProjectRepositoryPath;
+exports.zGithubGetProjectRepositoryResponse = zGithubGetProjectRepositoryResponse;
+exports.zGithubInstalledQuery = zGithubInstalledQuery;
+exports.zGithubIssuePath = zGithubIssuePath;
+exports.zGithubIssueResponse = zGithubIssueResponse;
+exports.zGithubLinkIssueBody = zGithubLinkIssueBody;
+exports.zGithubLinkIssuePath = zGithubLinkIssuePath;
+exports.zGithubLinkIssueResponse = zGithubLinkIssueResponse;
+exports.zGithubManifestBody = zGithubManifestBody;
+exports.zGithubManifestResponse = zGithubManifestResponse;
+exports.zGithubPutMyLoginBody = zGithubPutMyLoginBody;
+exports.zGithubPutMyLoginResponse = zGithubPutMyLoginResponse;
+exports.zGithubPutProjectRepositoryBody = zGithubPutProjectRepositoryBody;
+exports.zGithubPutProjectRepositoryPath = zGithubPutProjectRepositoryPath;
+exports.zGithubPutProjectRepositoryResponse = zGithubPutProjectRepositoryResponse;
+exports.zGithubRepositoriesQuery = zGithubRepositoriesQuery;
+exports.zGithubRepositoriesResponse = zGithubRepositoriesResponse;
+exports.zGithubStatusResponse = zGithubStatusResponse;
+exports.zGithubSyncCodeownersPath = zGithubSyncCodeownersPath;
+exports.zGithubSyncCodeownersResponse = zGithubSyncCodeownersResponse;
+exports.zGithubUnlinkIssuePath = zGithubUnlinkIssuePath;
+exports.zGithubUnlinkIssueResponse = zGithubUnlinkIssueResponse;
+exports.zGithubWebhookBody = zGithubWebhookBody;
+exports.zGithubWebhookResponse = zGithubWebhookResponse;
+exports.zGrouping = zGrouping;
+exports.zHealthLivenessResponse = zHealthLivenessResponse;
+exports.zHealthReadinessResponse = zHealthReadinessResponse;
+exports.zHealthVersionResponse = zHealthVersionResponse;
+exports.zIntervalUnit = zIntervalUnit;
+exports.zInvitationInfoResponse = zInvitationInfoResponse;
+exports.zInvitationResponse = zInvitationResponse;
+exports.zInvitationsCreateBody = zInvitationsCreateBody;
+exports.zInvitationsCreateResponse = zInvitationsCreateResponse;
+exports.zInvitationsListResponse = zInvitationsListResponse;
+exports.zInvitationsRevokePath = zInvitationsRevokePath;
+exports.zInvitationsRevokeResponse = zInvitationsRevokeResponse;
+exports.zIssueAggregates = zIssueAggregates;
+exports.zIssueFilter = zIssueFilter;
+exports.zIssueGitHub = zIssueGitHub;
+exports.zIssueLink = zIssueLink;
+exports.zIssuePriority = zIssuePriority;
+exports.zIssueResponse = zIssueResponse;
+exports.zIssueSort = zIssueSort;
+exports.zIssueStatsResponse = zIssueStatsResponse;
+exports.zIssueStatsWindow = zIssueStatsWindow;
+exports.zIssueStatus = zIssueStatus;
+exports.zIssueStatusUpdate = zIssueStatusUpdate;
+exports.zIssueTagValue = zIssueTagValue;
+exports.zIssueUpdate = zIssueUpdate;
+exports.zIssuesBulkDeleteBody = zIssuesBulkDeleteBody;
+exports.zIssuesBulkDeletePath = zIssuesBulkDeletePath;
+exports.zIssuesBulkDeleteResponse = zIssuesBulkDeleteResponse;
+exports.zIssuesBulkUpdateBody = zIssuesBulkUpdateBody;
+exports.zIssuesBulkUpdatePath = zIssuesBulkUpdatePath;
+exports.zIssuesBulkUpdateResponse = zIssuesBulkUpdateResponse;
+exports.zIssuesCreateCommentBody = zIssuesCreateCommentBody;
+exports.zIssuesCreateCommentPath = zIssuesCreateCommentPath;
+exports.zIssuesCreateCommentResponse = zIssuesCreateCommentResponse;
+exports.zIssuesCreateUserReportBody = zIssuesCreateUserReportBody;
+exports.zIssuesCreateUserReportPath = zIssuesCreateUserReportPath;
+exports.zIssuesCreateUserReportResponse = zIssuesCreateUserReportResponse;
+exports.zIssuesDeletePath = zIssuesDeletePath;
+exports.zIssuesDeleteResponse = zIssuesDeleteResponse;
+exports.zIssuesGetActivityPath = zIssuesGetActivityPath;
+exports.zIssuesGetActivityResponse = zIssuesGetActivityResponse;
+exports.zIssuesGetAggregatesPath = zIssuesGetAggregatesPath;
+exports.zIssuesGetAggregatesResponse = zIssuesGetAggregatesResponse;
+exports.zIssuesGetHashesPath = zIssuesGetHashesPath;
+exports.zIssuesGetHashesResponse = zIssuesGetHashesResponse;
+exports.zIssuesGetPath = zIssuesGetPath;
+exports.zIssuesGetResponse = zIssuesGetResponse;
+exports.zIssuesGetStatsPath = zIssuesGetStatsPath;
+exports.zIssuesGetStatsQuery = zIssuesGetStatsQuery;
+exports.zIssuesGetStatsResponse = zIssuesGetStatsResponse;
+exports.zIssuesGetTagValuesPath = zIssuesGetTagValuesPath;
+exports.zIssuesGetTagValuesResponse = zIssuesGetTagValuesResponse;
+exports.zIssuesListPath = zIssuesListPath;
+exports.zIssuesListQuery = zIssuesListQuery;
+exports.zIssuesListResponse = zIssuesListResponse;
+exports.zIssuesListUserReportsPath = zIssuesListUserReportsPath;
+exports.zIssuesListUserReportsResponse = zIssuesListUserReportsResponse;
+exports.zIssuesMarkSeenPath = zIssuesMarkSeenPath;
+exports.zIssuesMarkSeenResponse = zIssuesMarkSeenResponse;
+exports.zIssuesSetBookmarkBody = zIssuesSetBookmarkBody;
+exports.zIssuesSetBookmarkPath = zIssuesSetBookmarkPath;
+exports.zIssuesSetBookmarkResponse = zIssuesSetBookmarkResponse;
+exports.zIssuesSetSubscriptionBody = zIssuesSetSubscriptionBody;
+exports.zIssuesSetSubscriptionPath = zIssuesSetSubscriptionPath;
+exports.zIssuesSetSubscriptionResponse = zIssuesSetSubscriptionResponse;
+exports.zIssuesUpdateBody = zIssuesUpdateBody;
+exports.zIssuesUpdatePath = zIssuesUpdatePath;
+exports.zIssuesUpdateResponse = zIssuesUpdateResponse;
+exports.zKindAge = zKindAge;
+exports.zLinkGitHubIssue = zLinkGitHubIssue;
+exports.zLivenessResponse = zLivenessResponse;
+exports.zLoginRequest = zLoginRequest;
+exports.zLogsListPath = zLogsListPath;
+exports.zLogsListQuery = zLogsListQuery;
+exports.zLogsListResponse = zLogsListResponse;
+exports.zManifestRequest = zManifestRequest;
+exports.zManifestResponse = zManifestResponse;
+exports.zMcpSettings = zMcpSettings;
+exports.zMcpStatus = zMcpStatus;
+exports.zMembersListPath = zMembersListPath;
+exports.zMembersListResponse = zMembersListResponse;
+exports.zMembersRemovePath = zMembersRemovePath;
+exports.zMembersRemoveResponse = zMembersRemoveResponse;
+exports.zMembersUpsertBody = zMembersUpsertBody;
+exports.zMembersUpsertPath = zMembersUpsertPath;
+exports.zMembersUpsertResponse = zMembersUpsertResponse;
+exports.zMetricDelta = zMetricDelta;
+exports.zMonitorConfig = zMonitorConfig;
+exports.zMonitorConfigInput = zMonitorConfigInput;
+exports.zMonitorEnvironmentResponse = zMonitorEnvironmentResponse;
+exports.zMonitorEnvironmentStatus = zMonitorEnvironmentStatus;
+exports.zMonitorResponse = zMonitorResponse;
+exports.zMonitorsCreateBody = zMonitorsCreateBody;
+exports.zMonitorsCreatePath = zMonitorsCreatePath;
+exports.zMonitorsCreateResponse = zMonitorsCreateResponse;
+exports.zMonitorsDeletePath = zMonitorsDeletePath;
+exports.zMonitorsDeleteResponse = zMonitorsDeleteResponse;
+exports.zMonitorsGetPath = zMonitorsGetPath;
+exports.zMonitorsGetResponse = zMonitorsGetResponse;
+exports.zMonitorsListCheckinsPath = zMonitorsListCheckinsPath;
+exports.zMonitorsListCheckinsQuery = zMonitorsListCheckinsQuery;
+exports.zMonitorsListCheckinsResponse = zMonitorsListCheckinsResponse;
+exports.zMonitorsListPath = zMonitorsListPath;
+exports.zMonitorsListResponse = zMonitorsListResponse;
+exports.zMonitorsUpdateBody = zMonitorsUpdateBody;
+exports.zMonitorsUpdatePath = zMonitorsUpdatePath;
+exports.zMonitorsUpdateResponse = zMonitorsUpdateResponse;
+exports.zOAuthGrant = zOAuthGrant;
+exports.zOauthDecideAuthorizationBody = zOauthDecideAuthorizationBody;
+exports.zOauthDecideAuthorizationResponse = zOauthDecideAuthorizationResponse;
+exports.zOauthGetAuthorizationQuery = zOauthGetAuthorizationQuery;
+exports.zOauthGetAuthorizationResponse = zOauthGetAuthorizationResponse;
+exports.zOauthListGrantsResponse = zOauthListGrantsResponse;
+exports.zOauthRevokeGrantPath = zOauthRevokeGrantPath;
+exports.zOauthRevokeGrantResponse = zOauthRevokeGrantResponse;
+exports.zOrgDetails = zOrgDetails;
+exports.zPreviewSchedule = zPreviewSchedule;
+exports.zPreviewTemplateBody = zPreviewTemplateBody;
+exports.zPreviewTemplateResponse = zPreviewTemplateResponse;
+exports.zProjectAge = zProjectAge;
+exports.zProjectListStats = zProjectListStats;
+exports.zProjectMember = zProjectMember;
+exports.zProjectMemberResponse = zProjectMemberResponse;
+exports.zProjectRepository = zProjectRepository;
+exports.zProjectResponse = zProjectResponse;
+exports.zProjectRetention = zProjectRetention;
+exports.zProjectRole = zProjectRole;
+exports.zProjectStatsSummary = zProjectStatsSummary;
+exports.zProjectsCreateBody = zProjectsCreateBody;
+exports.zProjectsCreateResponse = zProjectsCreateResponse;
+exports.zProjectsDeletePath = zProjectsDeletePath;
+exports.zProjectsDeleteResponse = zProjectsDeleteResponse;
+exports.zProjectsGetPath = zProjectsGetPath;
+exports.zProjectsGetRateLimitsResponse = zProjectsGetRateLimitsResponse;
+exports.zProjectsGetResponse = zProjectsGetResponse;
+exports.zProjectsListQuery = zProjectsListQuery;
+exports.zProjectsListResponse = zProjectsListResponse;
+exports.zProjectsUpdateBody = zProjectsUpdateBody;
+exports.zProjectsUpdatePath = zProjectsUpdatePath;
+exports.zProjectsUpdateResponse = zProjectsUpdateResponse;
+exports.zProviderType = zProviderType;
+exports.zRateLimitsResponse = zRateLimitsResponse;
+exports.zReadinessChecks = zReadinessChecks;
+exports.zReadinessResponse = zReadinessResponse;
+exports.zReleaseResponse = zReleaseResponse;
+exports.zReleasesCreateBody = zReleasesCreateBody;
+exports.zReleasesCreatePath = zReleasesCreatePath;
+exports.zReleasesCreateResponse = zReleasesCreateResponse;
+exports.zReleasesFinalizeBody = zReleasesFinalizeBody;
+exports.zReleasesFinalizePath = zReleasesFinalizePath;
+exports.zReleasesFinalizeResponse = zReleasesFinalizeResponse;
+exports.zReleasesNewIssuesPath = zReleasesNewIssuesPath;
+exports.zReleasesNewIssuesQuery = zReleasesNewIssuesQuery;
+exports.zReleasesNewIssuesResponse = zReleasesNewIssuesResponse;
+exports.zRepoCommit = zRepoCommit;
+exports.zRetentionResponse = zRetentionResponse;
+exports.zRetentionRun = zRetentionRun;
+exports.zRetentionSettings = zRetentionSettings;
+exports.zRetentionWindows = zRetentionWindows;
+exports.zSchedule = zSchedule;
+exports.zSchedulePreview = zSchedulePreview;
+exports.zSchedulesPreviewBody = zSchedulesPreviewBody;
+exports.zSchedulesPreviewResponse = zSchedulesPreviewResponse;
+exports.zSeenResponse = zSeenResponse;
+exports.zSentryEvent = zSentryEvent;
+exports.zSentryGetIssuePath = zSentryGetIssuePath;
+exports.zSentryGetIssueResponse = zSentryGetIssueResponse;
+exports.zSentryGetLatestEventPath = zSentryGetLatestEventPath;
+exports.zSentryGetLatestEventResponse = zSentryGetLatestEventResponse;
+exports.zSentryGroupProject = zSentryGroupProject;
+exports.zSentryIssue = zSentryIssue;
+exports.zSentryIssueDetails = zSentryIssueDetails;
+exports.zSentryListIssuesPath = zSentryListIssuesPath;
+exports.zSentryListIssuesQuery = zSentryListIssuesQuery;
+exports.zSentryListIssuesResponse = zSentryListIssuesResponse;
+exports.zSentryListOrganizationsResponse = zSentryListOrganizationsResponse;
+exports.zSentryListProjectsQuery = zSentryListProjectsQuery;
+exports.zSentryListProjectsResponse = zSentryListProjectsResponse;
+exports.zSentryListReposPath = zSentryListReposPath;
+exports.zSentryListReposResponse = zSentryListReposResponse;
+exports.zSentryOpenIssuePath = zSentryOpenIssuePath;
+exports.zSentryOrganization = zSentryOrganization;
+exports.zSentryProject = zSentryProject;
+exports.zSentryRelease = zSentryRelease;
+exports.zSentryStatus = zSentryStatus;
+exports.zSentryTag = zSentryTag;
+exports.zSentryUpdateIssueBody = zSentryUpdateIssueBody;
+exports.zSentryUpdateIssuePath = zSentryUpdateIssuePath;
+exports.zSentryUpdateIssueResponse = zSentryUpdateIssueResponse;
+exports.zSessionSummary = zSessionSummary;
+exports.zSessionTimeseriesPoint = zSessionTimeseriesPoint;
+exports.zSessionsGetStatsPath = zSessionsGetStatsPath;
+exports.zSessionsGetStatsQuery = zSessionsGetStatsQuery;
+exports.zSessionsGetStatsResponse = zSessionsGetStatsResponse;
+exports.zSessionsGetSummaryPath = zSessionsGetSummaryPath;
+exports.zSessionsGetSummaryQuery = zSessionsGetSummaryQuery;
+exports.zSessionsGetSummaryResponse = zSessionsGetSummaryResponse;
+exports.zSessionsGetTimeseriesPath = zSessionsGetTimeseriesPath;
+exports.zSessionsGetTimeseriesQuery = zSessionsGetTimeseriesQuery;
+exports.zSessionsGetTimeseriesResponse = zSessionsGetTimeseriesResponse;
+exports.zSettingsGetMcpResponse = zSettingsGetMcpResponse;
+exports.zSettingsUpdateMcpBody = zSettingsUpdateMcpBody;
+exports.zSettingsUpdateMcpResponse = zSettingsUpdateMcpResponse;
+exports.zSortOrder = zSortOrder;
+exports.zSourceMapFile = zSourceMapFile;
+exports.zSourceMapGcResult = zSourceMapGcResult;
+exports.zSourceMapList = zSourceMapList;
+exports.zSourceMapStorage = zSourceMapStorage;
+exports.zSourceMapsArtifactBundleAssembleBody = zSourceMapsArtifactBundleAssembleBody;
+exports.zSourceMapsArtifactBundleAssemblePath = zSourceMapsArtifactBundleAssemblePath;
+exports.zSourceMapsArtifactBundleAssembleResponse = zSourceMapsArtifactBundleAssembleResponse;
+exports.zSourceMapsChunkUploadBody = zSourceMapsChunkUploadBody;
+exports.zSourceMapsChunkUploadCapabilityPath = zSourceMapsChunkUploadCapabilityPath;
+exports.zSourceMapsChunkUploadCapabilityResponse = zSourceMapsChunkUploadCapabilityResponse;
+exports.zSourceMapsChunkUploadPath = zSourceMapsChunkUploadPath;
+exports.zSourceMapsListPath = zSourceMapsListPath;
+exports.zSourceMapsListResponse = zSourceMapsListResponse;
+exports.zSourceMapsOrgDetailsPath = zSourceMapsOrgDetailsPath;
+exports.zSourceMapsOrgDetailsResponse = zSourceMapsOrgDetailsResponse;
+exports.zSpanDetailResponse = zSpanDetailResponse;
+exports.zSpanResponse = zSpanResponse;
+exports.zSpansGetPath = zSpansGetPath;
+exports.zSpansGetResponse = zSpansGetResponse;
+exports.zSpansListPath = zSpansListPath;
+exports.zSpansListQuery = zSpansListQuery;
+exports.zSpansListResponse = zSpansListResponse;
+exports.zSsoConfigResponse = zSsoConfigResponse;
+exports.zSsoLinkResponse = zSsoLinkResponse;
+exports.zSsoStartResponse = zSsoStartResponse;
+exports.zStatsGetEventTimeseriesPath = zStatsGetEventTimeseriesPath;
+exports.zStatsGetEventTimeseriesQuery = zStatsGetEventTimeseriesQuery;
+exports.zStatsGetEventTimeseriesResponse = zStatsGetEventTimeseriesResponse;
+exports.zStatsGetSummaryPath = zStatsGetSummaryPath;
+exports.zStatsGetSummaryQuery = zStatsGetSummaryQuery;
+exports.zStatsGetSummaryResponse = zStatsGetSummaryResponse;
+exports.zStorageAge = zStorageAge;
+exports.zStorageExecuteCleanupBody = zStorageExecuteCleanupBody;
+exports.zStorageExecuteCleanupResponse = zStorageExecuteCleanupResponse;
+exports.zStorageGcSourceMapsResponse = zStorageGcSourceMapsResponse;
+exports.zStorageGetAgeResponse = zStorageGetAgeResponse;
+exports.zStorageGetCleanupStatusResponse = zStorageGetCleanupStatusResponse;
+exports.zStorageGetProjectsResponse = zStorageGetProjectsResponse;
+exports.zStorageGetRetentionResponse = zStorageGetRetentionResponse;
+exports.zStorageGetSummaryResponse = zStorageGetSummaryResponse;
+exports.zStoragePreviewCleanupBody = zStoragePreviewCleanupBody;
+exports.zStoragePreviewCleanupResponse = zStoragePreviewCleanupResponse;
+exports.zStoragePreviewRetentionBody = zStoragePreviewRetentionBody;
+exports.zStoragePreviewRetentionResponse = zStoragePreviewRetentionResponse;
+exports.zStoragePreviewSourceMapGcResponse = zStoragePreviewSourceMapGcResponse;
+exports.zStorageRunRetentionResponse = zStorageRunRetentionResponse;
+exports.zStorageSummary = zStorageSummary;
+exports.zStorageUpdateRetentionBody = zStorageUpdateRetentionBody;
+exports.zStorageUpdateRetentionResponse = zStorageUpdateRetentionResponse;
+exports.zSubscriptionResponse = zSubscriptionResponse;
+exports.zTagSummary = zTagSummary;
+exports.zTagValueCount = zTagValueCount;
+exports.zTeamDeleteUserPath = zTeamDeleteUserPath;
+exports.zTeamDeleteUserResponse = zTeamDeleteUserResponse;
+exports.zTeamListResponse = zTeamListResponse;
+exports.zTeamMemberResponse = zTeamMemberResponse;
+exports.zTeamUpdateRoleBody = zTeamUpdateRoleBody;
+exports.zTeamUpdateRolePath = zTeamUpdateRolePath;
+exports.zTeamUpdateRoleResponse = zTeamUpdateRoleResponse;
+exports.zTelemetryPreview = zTelemetryPreview;
+exports.zTelemetryPreviewResponse = zTelemetryPreviewResponse;
+exports.zTestChannelResponse = zTestChannelResponse;
+exports.zTestIntegrationBody = zTestIntegrationBody;
+exports.zToggleRequest = zToggleRequest;
+exports.zTokensCreateBody = zTokensCreateBody;
+exports.zTokensCreateResponse = zTokensCreateResponse;
+exports.zTokensDeletePath = zTokensDeletePath;
+exports.zTokensDeleteResponse = zTokensDeleteResponse;
+exports.zTokensGetPath = zTokensGetPath;
+exports.zTokensGetResponse = zTokensGetResponse;
+exports.zTokensListResponse = zTokensListResponse;
+exports.zTransactionDetailResponse = zTransactionDetailResponse;
+exports.zTransactionStatsResponse = zTransactionStatsResponse;
+exports.zTransactionsGetPath = zTransactionsGetPath;
+exports.zTransactionsGetResponse = zTransactionsGetResponse;
+exports.zTransactionsGetSpansPath = zTransactionsGetSpansPath;
+exports.zTransactionsGetSpansResponse = zTransactionsGetSpansResponse;
+exports.zTransactionsGetStatGroupPath = zTransactionsGetStatGroupPath;
+exports.zTransactionsGetStatGroupQuery = zTransactionsGetStatGroupQuery;
+exports.zTransactionsGetStatGroupResponse = zTransactionsGetStatGroupResponse;
+exports.zTransactionsGetStatsPath = zTransactionsGetStatsPath;
+exports.zTransactionsGetStatsQuery = zTransactionsGetStatsQuery;
+exports.zTransactionsGetStatsResponse = zTransactionsGetStatsResponse;
+exports.zTransactionsListPath = zTransactionsListPath;
+exports.zTransactionsListQuery = zTransactionsListQuery;
+exports.zTransactionsListResponse = zTransactionsListResponse;
+exports.zUpdateAlertIntegration = zUpdateAlertIntegration;
+exports.zUpdateAlertRule = zUpdateAlertRule;
+exports.zUpdateIssueState = zUpdateIssueState;
+exports.zUpdateMonitor = zUpdateMonitor;
+exports.zUpdatePreferencesRequest = zUpdatePreferencesRequest;
+exports.zUpdateProject = zUpdateProject;
+exports.zUpdateProjectRepository = zUpdateProjectRepository;
+exports.zUpdateRelease = zUpdateRelease;
+exports.zUpdateUserRole = zUpdateUserRole;
+exports.zUpsertProjectMember = zUpsertProjectMember;
+exports.zUserReport = zUserReport;
+exports.zUserReportRequest = zUserReportRequest;
+exports.zUserResponse = zUserResponse;
+exports.zUserRole = zUserRole;
+exports.zVersionResponse = zVersionResponse;
+
+//# sourceMappingURL=zod.gen.cjs.map