@rustrak/client 0.18.0 → 0.19.0

package/dist/generated/zod.gen.mjs

@@ -0,0 +1,2618 @@
+import * as z from "zod";
+//#region src/generated/zod.gen.ts
+const zAcceptInvitation = z.object({
+	password: z.string(),
+	token: z.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 = z.object({
+	created_at: z.iso.datetime({ offset: true }),
+	data: z.string(),
+	id: z.uuid(),
+	issue_id: z.uuid(),
+	type: z.string(),
+	user_id: z.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 = z.object({
+	avg_ms: z.number(),
+	bucket: z.iso.datetime({ offset: true }),
+	p95_ms: z.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 = z.object({
+	avg_ms: z.number(),
+	cached_input_tokens: z.number(),
+	errors: z.int(),
+	input_tokens: z.number(),
+	model: z.string(),
+	output_tokens: z.number(),
+	p95_ms: z.number(),
+	reasoning_output_tokens: z.number(),
+	requests: z.int(),
+	total_tokens: z.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 = z.object({
+	agent_runs: z.int(),
+	avg_duration_ms: z.number(),
+	error_count: z.int(),
+	llm_calls: z.int(),
+	p95_duration_ms: z.number(),
+	tool_calls: z.int(),
+	total_tokens: z.number()
+});
+/**
+* One time-bucketed value (count or sum) — mirrors `SessionTimeseriesPoint`.
+*/
+const zAgentTimeseriesPoint = z.object({
+	bucket: z.iso.datetime({ offset: true }),
+	value: z.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 = z.object({
+	avg_ms: z.number(),
+	calls: z.int(),
+	errors: z.int(),
+	p95_ms: z.number(),
+	tool: z.string()
+});
+z.object({
+	agent_names: z.array(z.string()),
+	duration_ms: z.number().nullable(),
+	error_count: z.int(),
+	llm_call_count: z.int(),
+	started_at: z.iso.datetime({ offset: true }),
+	tool_call_count: z.int(),
+	total_tokens: z.number(),
+	trace_id: z.string()
+});
+/**
+* DTO for a channel with routing override in rule create/update
+*/
+const zAlertRuleChannelInput = z.object({
+	integration_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	routing_override: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* Status of an alert delivery attempt
+*/
+const zAlertStatus = z.enum([
+	"pending",
+	"sent",
+	"failed",
+	"skipped"
+]);
+/**
+* Alert delivery history record (audit log and retry queue)
+*/
+const zAlertHistory = z.object({
+	alert_rule_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+	alert_type: z.string(),
+	attempt_count: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	channel_name: z.string(),
+	channel_type: z.string(),
+	created_at: z.iso.datetime({ offset: true }),
+	error_message: z.string().nullable(),
+	http_status_code: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+	id: z.int(),
+	idempotency_key: z.string(),
+	integration_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+	issue_id: z.uuid().nullable(),
+	next_retry_at: z.iso.datetime({ offset: true }).nullable(),
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+	sent_at: z.iso.datetime({ offset: true }).nullable(),
+	status: zAlertStatus
+});
+/**
+* Type of alert trigger
+*/
+const zAlertType = z.enum([
+	"new_issue",
+	"regression",
+	"unmute"
+]);
+/**
+* Response for alert rule including linked integration info
+*/
+const zAlertRuleResponse = z.object({
+	alert_type: zAlertType,
+	channels: z.array(zAlertRuleChannelInput),
+	conditions: z.record(z.string(), z.unknown()),
+	cooldown_minutes: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	created_at: z.iso.datetime({ offset: true }),
+	id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	integration_ids: z.array(z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+	is_enabled: z.boolean(),
+	last_triggered_at: z.iso.datetime({ offset: true }).nullable(),
+	name: z.string(),
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	updated_at: z.iso.datetime({ offset: true })
+});
+const zAssembleBody = z.object({
+	checksum: z.string(),
+	chunks: z.array(z.string()),
+	projects: z.array(z.string())
+});
+const zAssembleResponse = z.object({
+	detail: z.string().nullish(),
+	missingChunks: z.array(z.string()),
+	state: z.string()
+});
+/**
+* Response that includes the full token (only on creation)
+*/
+const zAuthTokenCreatedResponse = z.object({
+	created_at: z.iso.datetime({ offset: true }),
+	description: z.string().nullable(),
+	id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	token: z.string()
+});
+/**
+* Response for listing (token is masked)
+*/
+const zAuthTokenResponse = z.object({
+	created_at: z.iso.datetime({ offset: true }),
+	description: z.string().nullable(),
+	id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	last_used_at: z.iso.datetime({ offset: true }).nullable(),
+	token_prefix: z.string()
+});
+/**
+* What the consent page shows about the client asking.
+*/
+const zAuthorizationInfo = z.object({
+	client_id: z.string(),
+	client_name: z.string(),
+	redirect_host: z.string()
+});
+/**
+* Where the consent page sends the browser next.
+*/
+const zAuthorizationRedirect = z.object({ redirect_to: z.string() });
+/**
+* An authorization request, as the client put it in the authorize URL.
+*/
+const zAuthorizationRequest = z.object({
+	client_id: z.string(),
+	code_challenge: z.string(),
+	code_challenge_method: z.string(),
+	redirect_uri: z.string(),
+	resource: z.string().nullish(),
+	response_type: z.string(),
+	state: z.string().nullish()
+});
+/**
+* The user's answer to a consent screen.
+*/
+const zAuthorizationDecision = zAuthorizationRequest.and(z.object({ approve: z.boolean() }));
+const zBookmarkResponse = z.object({ is_bookmarked: z.boolean() });
+const zBulkDeleteResponse = z.object({ deleted: z.int() });
+const zBulkUpdateResponse = z.object({ updated: z.int() });
+const zChangePasswordRequest = z.object({
+	current_password: z.string(),
+	new_password: z.string()
+});
+/**
+* Status of one check-in. `Missed` and `Timeout` are only ever set by the
+* server.
+*/
+const zCheckInStatus = z.enum([
+	"ok",
+	"error",
+	"in_progress",
+	"missed",
+	"timeout",
+	"unknown"
+]);
+/**
+* One check-in, as the dashboard reads it.
+*/
+const zCheckInResponse = z.object({
+	date_added: z.iso.datetime({ offset: true }),
+	date_updated: z.iso.datetime({ offset: true }),
+	duration_ms: z.int().nullable(),
+	environment: z.string(),
+	expected_time: z.iso.datetime({ offset: true }).nullable(),
+	id: z.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 = z.record(z.string(), z.unknown());
+/**
+* Chunk upload capabilities, in sentry-cli's camelCase.
+*/
+const zChunkUploadOptions = z.object({
+	accept: z.array(z.string()),
+	chunkSize: z.int().gte(0),
+	chunksPerRequest: z.int().gte(0),
+	compression: z.array(z.string()),
+	concurrency: z.int().gte(0),
+	hashAlgorithm: z.string(),
+	maxRequestSize: z.int().gte(0),
+	url: z.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 = z.object({
+	events: z.int(),
+	issues_removed: z.int(),
+	logs: z.int(),
+	source_maps: z.int(),
+	spans: z.int(),
+	transactions: z.int()
+});
+/**
+* How often the cleanup that enforces retention runs.
+*/
+const zCleanupFrequency = z.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 = z.object({
+	include_events: z.boolean().optional(),
+	include_logs: z.boolean().optional(),
+	include_transactions: z.boolean().optional(),
+	older_than_days: z.int().gte(1),
+	project_id: z.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 = z.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 = z.object({
+	error: z.string().nullable(),
+	finished_at: z.iso.datetime({ offset: true }).nullable(),
+	removed: zCleanupCounts,
+	started_at: z.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 = z.object({
+	source_root: z.string(),
+	stack_root: z.string()
+});
+/**
+* Body for creating an issue comment (note).
+*/
+const zCommentRequest = z.object({ text: z.string() });
+const zConfirmSsoLinkRequest = z.object({ password: z.string() });
+/**
+* DTO for creating an alert rule
+*/
+const zCreateAlertRule = z.object({
+	alert_type: zAlertType,
+	channels: z.array(zAlertRuleChannelInput).optional(),
+	conditions: z.record(z.string(), z.unknown()).optional(),
+	cooldown_minutes: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).optional(),
+	name: z.string()
+});
+/**
+* DTO for creating a new token
+*/
+const zCreateAuthToken = z.object({ description: z.string().nullish() });
+const zCreateGitHubIssue = z.object({
+	body: z.string().nullish(),
+	title: z.string().nullish()
+});
+/**
+* DTO for creating a new project
+*/
+const zCreateProject = z.object({
+	name: z.string(),
+	platform: z.string().nullish(),
+	slug: z.string().nullish()
+});
+/**
+* DTO for `POST .../releases/`.
+*/
+const zCreateRelease = z.object({
+	ref: z.string().nullish(),
+	url: z.string().nullish(),
+	version: z.string()
+});
+const zCreateUserRequest = z.object({
+	email: z.string(),
+	password: z.string()
+});
+/**
+* Response for API (full detail)
+*/
+const zEventDetailResponse = z.object({
+	data: z.record(z.string(), z.unknown()),
+	environment: z.string(),
+	event_id: z.string(),
+	event_type: z.string(),
+	id: z.uuid(),
+	ingested_at: z.iso.datetime({ offset: true }),
+	issue_id: z.uuid().nullable(),
+	level: z.string(),
+	platform: z.string(),
+	release: z.string(),
+	sdk_name: z.string(),
+	sdk_version: z.string(),
+	server_name: z.string(),
+	timestamp: z.iso.datetime({ offset: true }),
+	title: z.string()
+});
+z.object({
+	environment: z.string(),
+	event_id: z.string(),
+	event_type: z.string(),
+	id: z.uuid(),
+	issue_id: z.uuid().nullable(),
+	level: z.string(),
+	platform: z.string(),
+	release: z.string(),
+	timestamp: z.iso.datetime({ offset: true }),
+	title: z.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 = z.object({
+	bucket: z.iso.datetime({ offset: true }),
+	error: z.int(),
+	fatal: z.int(),
+	info: z.int(),
+	total: z.int(),
+	warning: z.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 = z.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 = z.object({
+	code: zFieldErrorCode,
+	field: z.string(),
+	message: z.string().optional()
+});
+const zErrorDetail = z.object({
+	fields: z.array(zFieldError).optional(),
+	incident_id: z.string().optional(),
+	message: z.string(),
+	type: z.string()
+});
+z.object({ error: zErrorDetail });
+/**
+* One row of a "top N by X" breakdown (model or tool name).
+*/
+const zGenAiBreakdownRow = z.object({
+	label: z.string(),
+	value: z.number()
+});
+const zGitHubAppInfo = z.object({
+	app_id: z.int(),
+	created_at: z.iso.datetime({ offset: true }),
+	html_url: z.string(),
+	install_url: z.string(),
+	last_webhook_at: z.iso.datetime({ offset: true }).nullable(),
+	owner_login: z.string(),
+	slug: z.string()
+});
+const zGitHubInstallation = z.object({
+	account_login: z.string(),
+	account_type: z.string(),
+	created_at: z.iso.datetime({ offset: true }),
+	id: z.int(),
+	suspended: z.boolean()
+});
+const zGitHubLogin = z.object({ login: z.string().nullable() });
+/**
+* A repository an installation can reach.
+*/
+const zGitHubRepository = z.object({
+	default_branch: z.string(),
+	full_name: z.string(),
+	html_url: z.string(),
+	installation_id: z.int(),
+	private: z.boolean()
+});
+/**
+* `GET /api/github`: everything the integrations page needs in one answer.
+*/
+const zGitHubStatus = z.object({
+	app: zGitHubAppInfo.nullable(),
+	installations: z.array(zGitHubInstallation),
+	webhook_url: z.string()
+});
+/**
+* Grouping model - maps a grouping key to an issue
+*/
+const zGrouping = z.object({
+	created_at: z.iso.datetime({ offset: true }),
+	grouping_key: z.string(),
+	grouping_key_hash: z.string(),
+	id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid(),
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+});
+const zIntervalUnit = z.enum([
+	"minute",
+	"hour",
+	"day",
+	"week",
+	"month",
+	"year"
+]);
+/**
+* Filter for issues listing
+*/
+const zIssueFilter = z.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 = z.union([z.object({ ids: z.array(z.uuid()) }), z.object({ filter: zIssueFilter })]);
+const zIssueLink = z.object({
+	created_at: z.iso.datetime({ offset: true }),
+	id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid(),
+	number: z.int(),
+	repo_full_name: z.string(),
+	state: z.string(),
+	title: z.string(),
+	url: z.string()
+});
+/**
+* Triage priority of an issue.
+*/
+const zIssuePriority = z.enum([
+	"low",
+	"medium",
+	"high"
+]);
+/**
+* Sort mode for issues listing
+*/
+const zIssueSort = z.enum([
+	"digest_order",
+	"last_seen",
+	"event_count"
+]);
+const zIssueStatsResponse = z.object({ data: z.array(z.array(z.int())) });
+/**
+* How far back issue stats reach.
+*/
+const zIssueStatsWindow = z.enum(["24h", "30d"]);
+/**
+* Lifecycle status of an issue (Sentry-compatible).
+*/
+const zIssueStatus = z.enum([
+	"unresolved",
+	"resolved",
+	"ignored"
+]);
+/**
+* Response for API
+*/
+const zIssueResponse = z.object({
+	assigned_to: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+	assignee_type: z.string().nullable(),
+	culprit: z.string(),
+	event_count: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	first_release: z.string(),
+	first_seen: z.iso.datetime({ offset: true }),
+	has_seen: z.boolean().nullish(),
+	id: z.uuid(),
+	is_bookmarked: z.boolean().nullish(),
+	is_muted: z.boolean(),
+	is_resolved: z.boolean(),
+	is_subscribed: z.boolean().nullish(),
+	issue_category: z.string(),
+	issue_type: z.string(),
+	last_release: z.string(),
+	last_seen: z.iso.datetime({ offset: true }),
+	level: z.string().nullable(),
+	logger: z.string(),
+	platform: z.string().nullable(),
+	priority: zIssuePriority.nullable(),
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	short_id: z.string(),
+	status: zIssueStatus,
+	status_details: z.record(z.string(), z.unknown()),
+	substatus: z.string().nullable(),
+	title: z.string(),
+	trend: z.array(z.int()).nullish(),
+	user_count: z.int().nullish(),
+	user_report_count: z.int().nullish(),
+	value: z.string()
+});
+/**
+* The status an update may set: an [`IssueStatus`], or `resolvedInNextRelease`
+* to resolve until the next release ships.
+*/
+const zIssueStatusUpdate = z.enum([
+	"unresolved",
+	"resolved",
+	"ignored",
+	"resolvedInNextRelease"
+]);
+/**
+* Bulk mutate request: apply a status (and/or priority) to many issues.
+*/
+const zBulkUpdateIssues = z.object({
+	ids: z.array(z.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 = z.object({
+	count: z.int(),
+	first_seen: z.iso.datetime({ offset: true }),
+	key: z.string(),
+	last_seen: z.iso.datetime({ offset: true }),
+	name: z.string(),
+	value: z.string()
+});
+/**
+* How long ago a kind of data arrived: rows per age bucket, and the oldest.
+*/
+const zKindAge = z.object({
+	counts: z.array(z.int()),
+	oldest: z.iso.datetime({ offset: true }).nullable()
+});
+const zLinkGitHubIssue = z.object({ reference: z.string() });
+const zLivenessResponse = z.object({ status: z.string() });
+z.object({
+	attributes: z.record(z.string(), z.unknown()),
+	body: z.string(),
+	id: z.uuid(),
+	ingested_at: z.iso.datetime({ offset: true }),
+	level: z.string(),
+	severity_number: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+	span_id: z.string().nullable(),
+	timestamp: z.iso.datetime({ offset: true }),
+	trace_id: z.string().nullable()
+});
+const zLoginRequest = z.object({
+	email: z.string(),
+	password: z.string()
+});
+const zManifestRequest = z.object({ organization: z.string().nullish() });
+/**
+* What the dashboard posts to GitHub to create the app.
+*/
+const zManifestResponse = z.object({
+	action_url: z.string(),
+	manifest: z.string()
+});
+/**
+* Turns `/mcp` on or off: the body of `PUT /api/settings/mcp`.
+*/
+const zMcpSettings = z.object({ enabled: z.boolean() });
+/**
+* Whether `/mcp` answers, and the URL to give an assistant.
+*/
+const zMcpStatus = z.object({
+	enabled: z.boolean(),
+	url: z.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 = z.object({
+	current: z.int(),
+	previous: z.int().nullable()
+});
+/**
+* Health of one monitor environment.
+*/
+const zMonitorEnvironmentStatus = z.enum([
+	"active",
+	"ok",
+	"error"
+]);
+/**
+* One environment of a monitor, with its most recent check-ins for the
+* timeline.
+*/
+const zMonitorEnvironmentResponse = z.object({
+	environment: z.string(),
+	id: z.uuid(),
+	last_checkin: z.iso.datetime({ offset: true }).nullable(),
+	next_checkin: z.iso.datetime({ offset: true }).nullable(),
+	next_checkin_latest: z.iso.datetime({ offset: true }).nullable(),
+	recent_checkins: z.array(zCheckInResponse),
+	status: zMonitorEnvironmentStatus
+});
+/**
+* A connected client, as its user sees it.
+*/
+const zOAuthGrant = z.object({
+	client_id: z.string(),
+	client_name: z.string(),
+	created_at: z.iso.datetime({ offset: true }),
+	id: z.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 = z.object({
+	features: z.array(z.string()),
+	id: z.string(),
+	name: z.string(),
+	slug: z.string()
+});
+/**
+* Body of a template preview request.
+*/
+const zPreviewTemplateBody = z.object({ template: z.string() });
+/**
+* `rendered` when `ok`, `error` otherwise.
+*/
+const zPreviewTemplateResponse = z.object({
+	error: z.string().nullish(),
+	ok: z.boolean(),
+	rendered: z.string().nullish()
+});
+const zProjectAge = z.object({
+	events: zKindAge,
+	logs: zKindAge,
+	project_id: z.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 = z.object({
+	events: zMetricDelta,
+	fatal_issues: z.int(),
+	new_issues: zMetricDelta,
+	open_issues: z.int(),
+	trend: z.array(z.int())
+});
+const zProjectRepository = z.object({
+	auto_create_conditions: z.record(z.string(), z.unknown()),
+	auto_create_issues: z.boolean(),
+	code_mappings: z.array(zCodeMapping),
+	codeowners_rules: z.int().gte(0).nullable(),
+	codeowners_synced_at: z.iso.datetime({ offset: true }).nullable(),
+	default_branch: z.string(),
+	html_url: z.string(),
+	installation_id: z.int(),
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	repo_full_name: z.string()
+});
+/**
+* Response with DSN included
+*/
+const zProjectResponse = z.object({
+	created_at: z.iso.datetime({ offset: true }),
+	digested_event_count: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	dsn: z.string(),
+	id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	name: z.string(),
+	platform: z.string().nullable(),
+	rate_limit_per_hour: z.int().nullable(),
+	rate_limit_per_minute: z.int().nullable(),
+	rate_limited_event_count: z.int(),
+	sentry_key: z.uuid(),
+	slug: z.string(),
+	stats: zProjectListStats.nullish(),
+	stored_event_count: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	updated_at: z.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 = z.object({
+	events_days: z.int().nullable(),
+	logs_days: z.int().nullable(),
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	transactions_days: z.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 = z.enum([
+	"viewer",
+	"editor",
+	"admin"
+]);
+const zProjectMember = z.object({
+	created_at: z.iso.datetime({ offset: true }),
+	id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	project_id: z.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: z.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 = z.object({
+	created_at: z.iso.datetime({ offset: true }),
+	email: z.string(),
+	role: zProjectRole,
+	user_id: z.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 = z.object({
+	events: zMetricDelta,
+	new_issues: zMetricDelta,
+	open_issues: z.int(),
+	period_hours: z.int().nullable()
+});
+z.object({
+	estimated_bytes: z.int(),
+	events_bytes: z.int(),
+	events_count: z.int(),
+	logs_bytes: z.int(),
+	logs_count: z.int(),
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	project_name: z.string(),
+	source_maps_count: z.int(),
+	spans_count: z.int(),
+	transactions_bytes: z.int(),
+	transactions_count: z.int()
+});
+/**
+* Type of notification provider (replaces ChannelType)
+*/
+const zProviderType = z.enum([
+	"webhook",
+	"email",
+	"slack",
+	"custom_webhook"
+]);
+/**
+* Global alert integration record — stores credentials only, no routing.
+*/
+const zAlertIntegration = z.object({
+	created_at: z.iso.datetime({ offset: true }),
+	credentials: z.record(z.string(), z.unknown()),
+	failure_count: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	is_enabled: z.boolean(),
+	last_failure_at: z.iso.datetime({ offset: true }).nullable(),
+	last_failure_message: z.string().nullable(),
+	last_success_at: z.iso.datetime({ offset: true }).nullable(),
+	name: z.string(),
+	provider_type: zProviderType,
+	updated_at: z.iso.datetime({ offset: true })
+});
+/**
+* DTO for creating an alert integration
+*/
+const zCreateAlertIntegration = z.object({
+	credentials: z.record(z.string(), z.unknown()),
+	is_enabled: z.boolean().optional(),
+	name: z.string(),
+	provider_type: zProviderType
+});
+/**
+* Configure project routes
+* The server's per-project event limits (`MAX_EVENTS_PER_PROJECT_*`).
+*/
+const zRateLimitsResponse = z.object({
+	project_per_hour: z.int(),
+	project_per_minute: z.int()
+});
+const zReadinessChecks = z.object({ database: z.string() });
+const zReadinessResponse = z.object({
+	checks: zReadinessChecks,
+	status: z.string()
+});
+z.object({
+	abnormal: z.int(),
+	crash_free_sessions_rate: z.number().nullable(),
+	crash_free_users_rate: z.number().nullable(),
+	crashed: z.int(),
+	environment: z.string(),
+	errored: z.int(),
+	healthy: z.int(),
+	release: z.string(),
+	total: z.int()
+});
+/**
+* API response for a release.
+*/
+const zReleaseResponse = z.object({
+	dateCreated: z.iso.datetime({ offset: true }),
+	dateReleased: z.iso.datetime({ offset: true }).nullable(),
+	ref: z.string().nullable(),
+	url: z.string().nullable(),
+	version: z.string()
+});
+const zRepoCommit = z.object({
+	author_login: z.string().nullable(),
+	author_name: z.string(),
+	committed_at: z.iso.datetime({ offset: true }),
+	message: z.string(),
+	repo_full_name: z.string(),
+	sha: z.string(),
+	url: z.string()
+});
+/**
+* `GET .../issues/{id}/github`: the issue's "Code" block in one answer.
+*/
+const zIssueGitHub = z.object({
+	links: z.array(zIssueLink),
+	owners: z.array(z.string()),
+	suspect_commits: z.array(zRepoCommit)
+});
+/**
+* How the last retention cleanup went.
+*/
+const zRetentionRun = z.object({
+	error: z.string().nullable(),
+	finished_at: z.iso.datetime({ offset: true }).nullable(),
+	removed: zCleanupCounts.nullable(),
+	started_at: z.iso.datetime({ offset: true }),
+	status: z.string()
+});
+/**
+* How long each kind of data is kept, in days. `None` keeps it forever.
+*/
+const zRetentionWindows = z.object({
+	events_days: z.int().nullable().default(null),
+	logs_days: z.int().nullable().default(null),
+	transactions_days: z.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 = z.object({
+	defaults: zRetentionWindows.default({
+		events_days: null,
+		logs_days: null,
+		transactions_days: null
+	}),
+	frequency: zCleanupFrequency.default("daily"),
+	hour: z.int().gte(0).lte(23).default(3),
+	overrides: z.array(zProjectRetention).default([]),
+	weekday: z.int().gte(0).lte(6).default(0)
+});
+const zRetentionResponse = z.object({
+	last_run: zRetentionRun.nullable(),
+	next_run_at: z.iso.datetime({ offset: true }).nullable(),
+	settings: zRetentionSettings
+});
+const zSchedule = z.union([z.object({
+	type: z.enum(["crontab"]),
+	value: z.string()
+}), z.object({
+	type: z.enum(["interval"]),
+	unit: zIntervalUnit,
+	value: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+})]);
+/**
+* A validated monitor configuration, with every default filled in.
+*/
+const zMonitorConfig = z.object({
+	checkin_margin: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	failure_issue_threshold: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	max_runtime: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	recovery_threshold: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	schedule: zSchedule,
+	timezone: z.string()
+});
+/**
+* `monitor_config` as an SDK or the dashboard sends it: every field optional.
+*/
+const zMonitorConfigInput = z.object({
+	checkin_margin: z.int().gte(0).nullish(),
+	failure_issue_threshold: z.int().gte(0).nullish(),
+	max_runtime: z.int().gte(0).nullish(),
+	recovery_threshold: z.int().gte(0).nullish(),
+	schedule: zSchedule.nullish(),
+	timezone: z.string().nullish()
+});
+/**
+* Body of `POST /api/projects/{project_id}/monitors`.
+*/
+const zCreateMonitor = z.object({
+	config: zMonitorConfigInput,
+	name: z.string(),
+	slug: z.string().nullish()
+});
+const zMonitorResponse = z.object({
+	config: zMonitorConfig,
+	created_at: z.iso.datetime({ offset: true }),
+	environments: z.array(zMonitorEnvironmentResponse),
+	id: z.uuid(),
+	is_muted: z.boolean(),
+	name: z.string(),
+	slug: z.string()
+});
+/**
+* Body of `POST /api/schedules/preview`.
+*/
+const zPreviewSchedule = z.object({
+	schedule: zSchedule,
+	timezone: z.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 = z.object({ next_runs: z.array(z.iso.datetime({ offset: true })) });
+const zSeenResponse = z.object({ has_seen: z.boolean() });
+/**
+* Project-wide session health summary, aggregated across all releases and environments.
+*/
+const zSessionSummary = z.object({
+	abnormal: z.int(),
+	active_releases: z.int(),
+	crash_free_sessions_rate: z.number().nullable(),
+	crash_free_users_rate: z.number().nullable(),
+	crashed: z.int(),
+	errored: z.int(),
+	total: z.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 = z.object({
+	bucket: z.iso.datetime({ offset: true }),
+	crash_free_sessions_rate: z.number().nullable(),
+	crashed: z.int(),
+	total: z.int()
+});
+/**
+* Sort order direction
+*/
+const zSortOrder = z.enum(["asc", "desc"]);
+const zSourceMapFile = z.object({
+	dateUploaded: z.string(),
+	debugId: z.string(),
+	fileType: z.string(),
+	size: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	timesUsed: z.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 = z.object({
+	bytes_freed: z.int(),
+	files_removed: z.int()
+});
+const zSourceMapList = z.object({ data: z.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 = z.object({
+	chunk_bytes: z.int(),
+	file_count: z.int(),
+	source_file_bytes: z.int(),
+	total_bytes: z.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 = z.object({
+	description: z.string().nullable(),
+	duration_ms: z.number().nullable(),
+	environment: z.string().nullable(),
+	exclusive_time_ms: z.number().nullable(),
+	gen_ai_agent_name: z.string().nullable(),
+	gen_ai_conversation_id: z.string().nullable(),
+	gen_ai_operation_type: z.string().nullable(),
+	gen_ai_request_model: z.string().nullable(),
+	gen_ai_response_model: z.string().nullable(),
+	gen_ai_tool_name: z.string().nullable(),
+	gen_ai_usage_input_tokens: z.number().nullable(),
+	gen_ai_usage_output_tokens: z.number().nullable(),
+	gen_ai_usage_total_tokens: z.number().nullable(),
+	id: z.uuid(),
+	is_segment: z.boolean(),
+	op: z.string().nullable(),
+	parent_span_id: z.string().nullable(),
+	platform: z.string().nullable(),
+	release: z.string().nullable(),
+	segment_id: z.string().nullable(),
+	span_id: z.string().nullable(),
+	start_timestamp: z.iso.datetime({ offset: true }).nullable(),
+	status: z.string().nullable(),
+	timestamp: z.iso.datetime({ offset: true }).nullable(),
+	trace_id: z.string().nullable(),
+	transaction_id: z.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(z.object({
+	attributes: z.record(z.string(), z.unknown()),
+	tags: z.record(z.string(), z.unknown()).nullable()
+}));
+const zSsoConfigResponse = z.object({
+	enabled: z.boolean(),
+	provider_name: z.string().nullable()
+});
+const zSsoLinkResponse = z.object({
+	email: z.string(),
+	provider_name: z.string()
+});
+const zSsoStartResponse = z.object({ authorization_url: z.string() });
+/**
+* The age of everything the instance holds, by project and kind, keyed on
+* ingest time like retention.
+*/
+const zStorageAge = z.object({
+	bucket_days: z.array(z.int()),
+	projects: z.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 = z.object({
+	events_count: z.int(),
+	logs_count: z.int(),
+	source_maps: zSourceMapStorage,
+	spans_count: z.int(),
+	total_db_size_bytes: z.int(),
+	transactions_count: z.int()
+});
+const zSubscriptionResponse = z.object({ is_subscribed: z.boolean() });
+/**
+* A tag value with its event count within an issue.
+*/
+const zTagValueCount = z.object({
+	count: z.int(),
+	value: z.string()
+});
+/**
+* A tag key with its most common values within an issue.
+*/
+const zTagSummary = z.object({
+	key: z.string(),
+	top_values: z.array(zTagValueCount),
+	total_values: z.int().gte(0)
+});
+/**
+* Per-issue aggregates computed from recent events (capped scan).
+*/
+const zIssueAggregates = z.object({
+	tags: z.array(zTagSummary),
+	user_count: z.int()
+});
+const zTelemetryPreview = z.object({
+	enabled: z.boolean(),
+	reason: z.string().nullable(),
+	report: z.record(z.string(), z.unknown()),
+	sink: z.string().nullable()
+});
+/**
+* Outcome of a test notification.
+*/
+const zTestChannelResponse = z.object({
+	message: z.string(),
+	response_body: z.string().nullable(),
+	success: z.boolean()
+});
+/**
+* Request body for the test-integration endpoint.
+*/
+const zTestIntegrationBody = z.object({ routing_override: z.record(z.string(), z.unknown()).nullish() });
+/**
+* Body for toggling a per-user flag (bookmark/subscription).
+*/
+const zToggleRequest = z.object({ enabled: z.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 = z.object({
+	data: z.record(z.string(), z.unknown()),
+	duration_ms: z.number().nullable(),
+	environment: z.string(),
+	event_id: z.string(),
+	id: z.uuid(),
+	ingested_at: z.iso.datetime({ offset: true }),
+	platform: z.string(),
+	release: z.string(),
+	start_timestamp: z.iso.datetime({ offset: true }).nullable(),
+	timestamp: z.iso.datetime({ offset: true }),
+	transaction_name: z.string()
+});
+z.object({
+	duration_ms: z.number().nullable(),
+	environment: z.string(),
+	event_id: z.string(),
+	id: z.uuid(),
+	ingested_at: z.iso.datetime({ offset: true }),
+	platform: z.string(),
+	release: z.string(),
+	start_timestamp: z.iso.datetime({ offset: true }).nullable(),
+	timestamp: z.iso.datetime({ offset: true }),
+	transaction_name: z.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 = z.object({
+	count: z.int(),
+	failure_rate: z.number(),
+	op: z.string().nullable(),
+	p50_ms: z.number(),
+	p95_ms: z.number(),
+	p99_ms: z.number(),
+	transaction_name: z.string()
+});
+/**
+* DTO for updating an alert integration
+*/
+const zUpdateAlertIntegration = z.object({
+	credentials: z.record(z.string(), z.unknown()).nullish(),
+	is_enabled: z.boolean().nullish(),
+	name: z.string().nullish()
+});
+/**
+* DTO for updating an alert rule
+*/
+const zUpdateAlertRule = z.object({
+	channels: z.array(zAlertRuleChannelInput).nullish(),
+	conditions: z.record(z.string(), z.unknown()).nullish(),
+	cooldown_minutes: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullish(),
+	is_enabled: z.boolean().nullish(),
+	name: z.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 = z.object({
+	assigned_to: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullish(),
+	assignee_type: z.string().nullish(),
+	is_muted: z.boolean().nullish(),
+	is_resolved: z.boolean().nullish(),
+	priority: zIssuePriority.nullish(),
+	status: zIssueStatusUpdate.nullish(),
+	substatus: z.string().nullish()
+});
+/**
+* Body of `PUT /api/projects/{project_id}/monitors/{slug}`. Fields left out
+* keep their value, including each field of `config`.
+*/
+const zUpdateMonitor = z.object({
+	config: zMonitorConfigInput.nullish(),
+	is_muted: z.boolean().nullish(),
+	name: z.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 = z.object({
+	language: z.string().nullish(),
+	timezone: z.string().nullish()
+});
+/**
+* DTO for updating a project
+*/
+const zUpdateProject = z.object({
+	name: z.string().nullish(),
+	platform: z.string().nullish(),
+	rate_limit_per_hour: z.int().nullish(),
+	rate_limit_per_minute: z.int().nullish(),
+	slug: z.string().nullish()
+});
+const zUpdateProjectRepository = z.object({
+	auto_create_conditions: z.record(z.string(), z.unknown()).nullish(),
+	auto_create_issues: z.boolean().nullish(),
+	code_mappings: z.array(zCodeMapping).nullish(),
+	installation_id: z.int(),
+	repo_full_name: z.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 = z.object({
+	dateReleased: z.iso.datetime({ offset: true }).nullish(),
+	ref: z.string().nullish(),
+	url: z.string().nullish()
+});
+const zUpsertProjectMember = z.object({
+	role: zProjectRole,
+	user_id: z.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 = z.object({
+	comments: z.string(),
+	created_at: z.iso.datetime({ offset: true }),
+	email: z.string(),
+	event_id: z.uuid().nullable(),
+	id: z.uuid(),
+	issue_id: z.uuid().nullable(),
+	name: z.string(),
+	project_id: z.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 = z.object({
+	comments: z.string().nullish(),
+	email: z.string().nullish(),
+	event_id: z.uuid().nullish(),
+	name: z.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 = z.enum(["admin", "member"]);
+const zCreateInvitation = z.object({
+	email: z.string(),
+	role: zUserRole
+});
+/**
+* Public-facing invitation info for the accept page.
+*/
+const zInvitationInfoResponse = z.object({
+	email: z.string(),
+	expires_at: z.iso.datetime({ offset: true }),
+	role: zUserRole,
+	status: z.string()
+});
+/**
+* Public-facing invitation (no internal columns beyond what the UI needs).
+*/
+const zInvitationResponse = z.object({
+	created_at: z.iso.datetime({ offset: true }),
+	email: z.string(),
+	expires_at: z.iso.datetime({ offset: true }),
+	role: zUserRole,
+	status: z.string(),
+	token: z.string()
+});
+/**
+* A user as exposed on the team roster.
+*/
+const zTeamMemberResponse = z.object({
+	created_at: z.iso.datetime({ offset: true }),
+	email: z.string(),
+	id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	is_active: z.boolean(),
+	is_primary: z.boolean(),
+	last_login: z.iso.datetime({ offset: true }).nullable(),
+	role: zUserRole
+});
+/**
+* Request body for changing a user's global role.
+*/
+const zUpdateUserRole = z.object({ role: zUserRole });
+const zUserResponse = z.object({
+	email: z.string(),
+	id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	is_admin: z.boolean(),
+	language: z.string().nullable(),
+	role: zUserRole,
+	timezone: z.string().nullable()
+});
+const zAuthResponse = z.object({ user: zUserResponse });
+const zVersionResponse = z.object({ version: z.string() });
+const zSourceMapsOrgDetailsPath = z.object({ org_slug: z.string() });
+/**
+* Synthetic org metadata accepted by sentry-cli
+*/
+const zSourceMapsOrgDetailsResponse = zOrgDetails;
+const zSourceMapsArtifactBundleAssembleBody = zAssembleBody;
+const zSourceMapsArtifactBundleAssemblePath = z.object({ org_slug: z.string() });
+/**
+* Assembly job state (not_found / created / assembling / ok / error). Missing chunks are listed in missingChunks.
+*/
+const zSourceMapsArtifactBundleAssembleResponse = zAssembleResponse;
+const zSourceMapsChunkUploadCapabilityPath = z.object({ org_slug: z.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 = z.object({ org_slug: z.string() });
+const zSourceMapsListPath = z.object({
+	org_slug: z.string(),
+	project_slug: z.string()
+});
+/**
+* List of uploaded source map files
+*/
+const zSourceMapsListResponse = zSourceMapList;
+const zReleasesCreateBody = zCreateRelease;
+const zReleasesCreatePath = z.object({
+	org_slug: z.string(),
+	project_slug: z.string()
+});
+/**
+* Release created
+*/
+const zReleasesCreateResponse = zReleaseResponse;
+const zReleasesFinalizeBody = zUpdateRelease;
+const zReleasesFinalizePath = z.object({
+	org_slug: z.string(),
+	project_slug: z.string(),
+	version: z.string()
+});
+/**
+* Release updated
+*/
+const zReleasesFinalizeResponse = zReleaseResponse;
+/**
+* GitHub App removed
+*/
+const zGithubDisconnectResponse = z.void();
+/**
+* GitHub App and installations
+*/
+const zGithubStatusResponse = zGitHubStatus;
+const zGithubCallbackQuery = z.object({
+	code: z.string(),
+	state: z.string()
+});
+const zGithubInstalledQuery = z.object({ installation_id: z.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 = z.object({ project_id: z.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 = z.array(zGitHubRepository);
+/**
+* GitHub event payload, signed in X-Hub-Signature-256
+*/
+const zGithubWebhookBody = z.record(z.string(), z.unknown());
+/**
+* Event processed
+*/
+const zGithubWebhookResponse = z.void();
+/**
+* List of notification channels
+*/
+const zAlertChannelsListResponse = z.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 = z.object({ id: z.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 = z.void();
+const zAlertChannelsGetPath = z.object({ id: z.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 = z.object({ id: z.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 = z.object({ id: z.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 = z.array(zInvitationResponse);
+const zInvitationsCreateBody = zCreateInvitation;
+/**
+* Invitation created
+*/
+const zInvitationsCreateResponse = zInvitationResponse;
+const zInvitationsRevokePath = z.object({ token: z.string() });
+/**
+* Invitation revoked
+*/
+const zInvitationsRevokeResponse = z.void();
+const zOauthGetAuthorizationQuery = z.object({
+	response_type: z.string(),
+	client_id: z.string(),
+	redirect_uri: z.string(),
+	code_challenge: z.string(),
+	code_challenge_method: z.string(),
+	state: z.string().nullish(),
+	resource: z.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 = z.array(zOAuthGrant);
+const zOauthRevokeGrantPath = z.object({ id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+/**
+* Disconnected
+*/
+const zOauthRevokeGrantResponse = z.void();
+const zProjectsListQuery = z.object({
+	page: z.int().gte(1).optional(),
+	per_page: z.int().gte(1).lte(100).optional(),
+	order: zSortOrder.optional(),
+	stats_period: z.string().nullish()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zProjectsListResponse = z.object({
+	items: z.array(z.object({
+		created_at: z.iso.datetime({ offset: true }),
+		digested_event_count: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+		dsn: z.string(),
+		id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+		name: z.string(),
+		platform: z.string().nullable(),
+		rate_limit_per_hour: z.int().nullable(),
+		rate_limit_per_minute: z.int().nullable(),
+		rate_limited_event_count: z.int(),
+		sentry_key: z.uuid(),
+		slug: z.string(),
+		stats: zProjectListStats.nullish(),
+		stored_event_count: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+		updated_at: z.iso.datetime({ offset: true })
+	})),
+	page: z.int(),
+	per_page: z.int(),
+	total_count: z.int(),
+	total_pages: z.int()
+});
+const zProjectsCreateBody = zCreateProject;
+/**
+* Project created
+*/
+const zProjectsCreateResponse = zProjectResponse;
+const zProjectsDeletePath = z.object({ id: z.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 = z.void();
+const zProjectsGetPath = z.object({ id: z.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 = z.object({ id: z.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 = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsDurationQuery = z.object({
+	period_hours: z.int().nullish(),
+	environment: z.string().nullish(),
+	interval_hours: z.int().gte(1).optional()
+});
+/**
+* Avg/p95 duration over time for agent runs and LLM calls
+*/
+const zAgentsDurationResponse = z.array(zAgentDurationPoint);
+const zAgentsEnvironmentsPath = z.object({ project_id: z.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 = z.array(z.string());
+const zAgentsModelsTablePath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsModelsTableQuery = z.object({
+	period_hours: z.int().nullish(),
+	environment: z.string().nullish()
+});
+/**
+* Per-model volume, failures, latency and token split
+*/
+const zAgentsModelsTableResponse = z.array(zAgentModelRow);
+const zAgentsModelsCallsPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsModelsCallsQuery = z.object({
+	period_hours: z.int().nullish(),
+	environment: z.string().nullish(),
+	limit: z.int().gte(1).lte(100).optional()
+});
+/**
+* Top LLM call counts by response model
+*/
+const zAgentsModelsCallsResponse = z.array(zGenAiBreakdownRow);
+const zAgentsModelsTokensPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsModelsTokensQuery = z.object({
+	period_hours: z.int().nullish(),
+	environment: z.string().nullish(),
+	limit: z.int().gte(1).lte(100).optional()
+});
+/**
+* Top total tokens used by response model
+*/
+const zAgentsModelsTokensResponse = z.array(zGenAiBreakdownRow);
+const zAgentsRunsPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsRunsQuery = z.object({
+	period_hours: z.int().nullish(),
+	environment: z.string().nullish(),
+	interval_hours: z.int().gte(1).optional()
+});
+/**
+* Agent runs over time
+*/
+const zAgentsRunsResponse = z.array(zAgentTimeseriesPoint);
+const zAgentsSummaryPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsSummaryQuery = z.object({
+	period_hours: z.int().nullish(),
+	environment: z.string().nullish()
+});
+/**
+* Headline totals for the selected window
+*/
+const zAgentsSummaryResponse = zAgentSummary;
+const zAgentsToolsPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsToolsQuery = z.object({
+	period_hours: z.int().nullish(),
+	environment: z.string().nullish(),
+	limit: z.int().gte(1).lte(100).optional()
+});
+/**
+* Top tool call counts by tool name
+*/
+const zAgentsToolsResponse = z.array(zGenAiBreakdownRow);
+const zAgentsToolsTablePath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsToolsTableQuery = z.object({
+	period_hours: z.int().nullish(),
+	environment: z.string().nullish()
+});
+/**
+* Per-tool call volume, failures and latency
+*/
+const zAgentsToolsTableResponse = z.array(zAgentToolRow);
+const zAgentsTracesPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAgentsTracesQuery = z.object({
+	period_hours: z.int().nullish(),
+	environment: z.string().nullish(),
+	page: z.int().gte(1).optional(),
+	per_page: z.int().gte(1).lte(100).optional()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zAgentsTracesResponse = z.object({
+	items: z.array(z.object({
+		agent_names: z.array(z.string()),
+		duration_ms: z.number().nullable(),
+		error_count: z.int(),
+		llm_call_count: z.int(),
+		started_at: z.iso.datetime({ offset: true }),
+		tool_call_count: z.int(),
+		total_tokens: z.number(),
+		trace_id: z.string()
+	})),
+	page: z.int(),
+	per_page: z.int(),
+	total_count: z.int(),
+	total_pages: z.int()
+});
+const zAlertRulesListHistoryPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zAlertRulesListHistoryQuery = z.object({ limit: z.int().optional() });
+/**
+* Alert history
+*/
+const zAlertRulesListHistoryResponse = z.array(zAlertHistory);
+const zAlertRulesListPath = z.object({ project_id: z.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 = z.array(zAlertRuleResponse);
+const zAlertRulesCreateBody = zCreateAlertRule;
+const zAlertRulesCreatePath = z.object({ project_id: z.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 = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	rule_id: z.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 = z.void();
+const zAlertRulesGetPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	rule_id: z.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 = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	rule_id: z.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 = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	event_id: z.string()
+});
+/**
+* Full event detail, including its issue ID
+*/
+const zEventsGetBySentryIdResponse = zEventDetailResponse;
+const zStatsGetEventTimeseriesPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zStatsGetEventTimeseriesQuery = z.object({
+	period: z.string().optional(),
+	interval: z.int().optional()
+});
+/**
+* Time-bucketed error-event volume by severity
+*/
+const zStatsGetEventTimeseriesResponse = z.array(zEventTimeseriesPoint);
+const zGithubDeleteProjectRepositoryPath = z.object({ project_id: z.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 = z.void();
+const zGithubGetProjectRepositoryPath = z.object({ project_id: z.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 = z.object({ project_id: z.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 = z.object({ project_id: z.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 = z.object({ project_id: z.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 = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zIssuesListQuery = z.object({
+	page: z.int().gte(1).optional(),
+	per_page: z.int().gte(1).lte(100).optional(),
+	sort: zIssueSort.optional(),
+	order: zSortOrder.optional(),
+	filter: zIssueFilter.optional(),
+	q: z.string().nullish()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zIssuesListResponse = z.object({
+	items: z.array(z.object({
+		assigned_to: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+		assignee_type: z.string().nullable(),
+		culprit: z.string(),
+		event_count: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+		first_release: z.string(),
+		first_seen: z.iso.datetime({ offset: true }),
+		has_seen: z.boolean().nullish(),
+		id: z.uuid(),
+		is_bookmarked: z.boolean().nullish(),
+		is_muted: z.boolean(),
+		is_resolved: z.boolean(),
+		is_subscribed: z.boolean().nullish(),
+		issue_category: z.string(),
+		issue_type: z.string(),
+		last_release: z.string(),
+		last_seen: z.iso.datetime({ offset: true }),
+		level: z.string().nullable(),
+		logger: z.string(),
+		platform: z.string().nullable(),
+		priority: zIssuePriority.nullable(),
+		project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+		short_id: z.string(),
+		status: zIssueStatus,
+		status_details: z.record(z.string(), z.unknown()),
+		substatus: z.string().nullable(),
+		title: z.string(),
+		trend: z.array(z.int()).nullish(),
+		user_count: z.int().nullish(),
+		user_report_count: z.int().nullish(),
+		value: z.string()
+	})),
+	page: z.int(),
+	per_page: z.int(),
+	total_count: z.int(),
+	total_pages: z.int()
+});
+const zIssuesBulkUpdateBody = zBulkUpdateIssues;
+const zIssuesBulkUpdatePath = z.object({ project_id: z.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 = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+/**
+* Issue deleted
+*/
+const zIssuesDeleteResponse = z.void();
+const zIssuesGetPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+/**
+* Issue details
+*/
+const zIssuesGetResponse = zIssueResponse;
+const zIssuesUpdateBody = zUpdateIssueState;
+const zIssuesUpdatePath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+/**
+* Issue updated
+*/
+const zIssuesUpdateResponse = zIssueResponse;
+const zIssuesGetActivityPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+/**
+* Activity log (status changes, comments, …)
+*/
+const zIssuesGetActivityResponse = z.array(zActivityEntry);
+const zIssuesGetAggregatesPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+/**
+* Unique user count and top tags
+*/
+const zIssuesGetAggregatesResponse = zIssueAggregates;
+const zIssuesSetBookmarkBody = zToggleRequest;
+const zIssuesSetBookmarkPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+/**
+* Updated bookmark state
+*/
+const zIssuesSetBookmarkResponse = zBookmarkResponse;
+const zIssuesCreateCommentBody = zCommentRequest;
+const zIssuesCreateCommentPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+/**
+* Comment added
+*/
+const zIssuesCreateCommentResponse = zActivityEntry;
+const zEventsListPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+const zEventsListQuery = z.object({
+	order: zSortOrder.optional(),
+	cursor: z.string().nullish()
+});
+/**
+* Paginated response wrapper (cursor-based)
+*/
+const zEventsListResponse = z.object({
+	has_more: z.boolean(),
+	items: z.array(z.object({
+		environment: z.string(),
+		event_id: z.string(),
+		event_type: z.string(),
+		id: z.uuid(),
+		issue_id: z.uuid().nullable(),
+		level: z.string(),
+		platform: z.string(),
+		release: z.string(),
+		timestamp: z.iso.datetime({ offset: true }),
+		title: z.string()
+	})),
+	next_cursor: z.string().nullish()
+});
+const zEventsGetPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid(),
+	event_id: z.uuid()
+});
+/**
+* Full event detail
+*/
+const zEventsGetResponse = zEventDetailResponse;
+const zGithubIssuePath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+/**
+* Links, suspect commits and owners
+*/
+const zGithubIssueResponse = zIssueGitHub;
+const zGithubCreateIssueBody = zCreateGitHubIssue;
+const zGithubCreateIssuePath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+/**
+* GitHub issue created and linked
+*/
+const zGithubCreateIssueResponse = zIssueLink;
+const zGithubLinkIssueBody = zLinkGitHubIssue;
+const zGithubLinkIssuePath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+/**
+* GitHub issue linked
+*/
+const zGithubLinkIssueResponse = zIssueLink;
+const zGithubUnlinkIssuePath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid(),
+	link_id: z.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 = z.void();
+const zIssuesGetHashesPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+/**
+* Grouping hashes mapped to the issue
+*/
+const zIssuesGetHashesResponse = z.array(zGrouping);
+const zIssuesMarkSeenPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+/**
+* Issue marked as seen
+*/
+const zIssuesMarkSeenResponse = zSeenResponse;
+const zIssuesGetStatsPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+const zIssuesGetStatsQuery = z.object({ window: zIssueStatsWindow.optional() });
+/**
+* Zero-filled event-count timeseries
+*/
+const zIssuesGetStatsResponse = zIssueStatsResponse;
+const zIssuesSetSubscriptionBody = zToggleRequest;
+const zIssuesSetSubscriptionPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+/**
+* Updated subscription state
+*/
+const zIssuesSetSubscriptionResponse = zSubscriptionResponse;
+const zIssuesGetTagValuesPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid(),
+	key: z.string()
+});
+/**
+* Distinct values for the tag key, one entry per value (Sentry-compatible: a bare list, not wrapped)
+*/
+const zIssuesGetTagValuesResponse = z.array(zIssueTagValue);
+const zIssuesListUserReportsPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+/**
+* User feedback reports for the issue
+*/
+const zIssuesListUserReportsResponse = z.array(zUserReport);
+const zIssuesCreateUserReportBody = zUserReportRequest;
+const zIssuesCreateUserReportPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	issue_id: z.uuid()
+});
+/**
+* User feedback attached
+*/
+const zIssuesCreateUserReportResponse = zUserReport;
+const zLogsListPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zLogsListQuery = z.object({
+	page: z.int().gte(1).optional(),
+	per_page: z.int().gte(1).lte(100).optional(),
+	level: z.string().nullish(),
+	trace_id: z.string().nullish()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zLogsListResponse = z.object({
+	items: z.array(z.object({
+		attributes: z.record(z.string(), z.unknown()),
+		body: z.string(),
+		id: z.uuid(),
+		ingested_at: z.iso.datetime({ offset: true }),
+		level: z.string(),
+		severity_number: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }).nullable(),
+		span_id: z.string().nullable(),
+		timestamp: z.iso.datetime({ offset: true }),
+		trace_id: z.string().nullable()
+	})),
+	page: z.int(),
+	per_page: z.int(),
+	total_count: z.int(),
+	total_pages: z.int()
+});
+const zMembersListPath = z.object({ project_id: z.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 = z.array(zProjectMemberResponse);
+const zMembersUpsertBody = zUpsertProjectMember;
+const zMembersUpsertPath = z.object({ project_id: z.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 = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	user_id: z.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 = z.void();
+const zMonitorsListPath = z.object({ project_id: z.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 = z.array(zMonitorResponse);
+const zMonitorsCreateBody = zCreateMonitor;
+const zMonitorsCreatePath = z.object({ project_id: z.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 = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	slug: z.string()
+});
+/**
+* Deleted with its check-ins; its issues stay
+*/
+const zMonitorsDeleteResponse = z.void();
+const zMonitorsGetPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	slug: z.string()
+});
+/**
+* The monitor
+*/
+const zMonitorsGetResponse = zMonitorResponse;
+const zMonitorsUpdateBody = zUpdateMonitor;
+const zMonitorsUpdatePath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	slug: z.string()
+});
+/**
+* Updated
+*/
+const zMonitorsUpdateResponse = zMonitorResponse;
+const zMonitorsListCheckinsPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	slug: z.string()
+});
+const zMonitorsListCheckinsQuery = z.object({
+	page: z.int().optional(),
+	per_page: z.int().optional(),
+	environment: z.string().nullish()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zMonitorsListCheckinsResponse = z.object({
+	items: z.array(z.object({
+		date_added: z.iso.datetime({ offset: true }),
+		date_updated: z.iso.datetime({ offset: true }),
+		duration_ms: z.int().nullable(),
+		environment: z.string(),
+		expected_time: z.iso.datetime({ offset: true }).nullable(),
+		id: z.uuid(),
+		status: zCheckInStatus
+	})),
+	page: z.int(),
+	per_page: z.int(),
+	total_count: z.int(),
+	total_pages: z.int()
+});
+const zReleasesNewIssuesPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	release: z.string()
+});
+const zReleasesNewIssuesQuery = z.object({ limit: z.int().optional() });
+/**
+* Issues first seen in this release, most recent first
+*/
+const zReleasesNewIssuesResponse = z.array(zIssueResponse);
+const zSessionsGetStatsPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zSessionsGetStatsQuery = z.object({
+	period: z.string().nullish(),
+	release: z.string().nullish(),
+	page: z.int().gte(1).optional(),
+	per_page: z.int().gte(1).lte(100).optional()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zSessionsGetStatsResponse = z.object({
+	items: z.array(z.object({
+		abnormal: z.int(),
+		crash_free_sessions_rate: z.number().nullable(),
+		crash_free_users_rate: z.number().nullable(),
+		crashed: z.int(),
+		environment: z.string(),
+		errored: z.int(),
+		healthy: z.int(),
+		release: z.string(),
+		total: z.int()
+	})),
+	page: z.int(),
+	per_page: z.int(),
+	total_count: z.int(),
+	total_pages: z.int()
+});
+const zSessionsGetSummaryPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zSessionsGetSummaryQuery = z.object({ period: z.string().optional() });
+/**
+* Project-wide session health summary
+*/
+const zSessionsGetSummaryResponse = zSessionSummary;
+const zSessionsGetTimeseriesPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zSessionsGetTimeseriesQuery = z.object({
+	period: z.string().optional(),
+	interval: z.int().optional()
+});
+/**
+* Time-bucketed session trend, project-wide
+*/
+const zSessionsGetTimeseriesResponse = z.array(zSessionTimeseriesPoint);
+const zSpansListPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zSpansListQuery = z.object({
+	page: z.int().gte(1).optional(),
+	per_page: z.int().gte(1).lte(100).optional(),
+	op: z.string().nullish(),
+	status: z.string().nullish(),
+	trace_id: z.string().nullish(),
+	operation_type: z.string().nullish()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zSpansListResponse = z.object({
+	items: z.array(z.object({
+		description: z.string().nullable(),
+		duration_ms: z.number().nullable(),
+		environment: z.string().nullable(),
+		exclusive_time_ms: z.number().nullable(),
+		gen_ai_agent_name: z.string().nullable(),
+		gen_ai_conversation_id: z.string().nullable(),
+		gen_ai_operation_type: z.string().nullable(),
+		gen_ai_request_model: z.string().nullable(),
+		gen_ai_response_model: z.string().nullable(),
+		gen_ai_tool_name: z.string().nullable(),
+		gen_ai_usage_input_tokens: z.number().nullable(),
+		gen_ai_usage_output_tokens: z.number().nullable(),
+		gen_ai_usage_total_tokens: z.number().nullable(),
+		id: z.uuid(),
+		is_segment: z.boolean(),
+		op: z.string().nullable(),
+		parent_span_id: z.string().nullable(),
+		platform: z.string().nullable(),
+		release: z.string().nullable(),
+		segment_id: z.string().nullable(),
+		span_id: z.string().nullable(),
+		start_timestamp: z.iso.datetime({ offset: true }).nullable(),
+		status: z.string().nullable(),
+		timestamp: z.iso.datetime({ offset: true }).nullable(),
+		trace_id: z.string().nullable(),
+		transaction_id: z.uuid().nullable()
+	})),
+	page: z.int(),
+	per_page: z.int(),
+	total_count: z.int(),
+	total_pages: z.int()
+});
+const zSpansGetPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	span_id: z.uuid()
+});
+/**
+* Span with its full attribute bag
+*/
+const zSpansGetResponse = zSpanDetailResponse;
+const zStatsGetSummaryPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zStatsGetSummaryQuery = z.object({ period: z.string().optional() });
+/**
+* Project counters with previous-period comparison
+*/
+const zStatsGetSummaryResponse = zProjectStatsSummary;
+const zTransactionsListPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zTransactionsListQuery = z.object({
+	page: z.int().gte(1).optional(),
+	per_page: z.int().gte(1).lte(100).optional(),
+	name: z.string().nullish(),
+	op: z.string().nullish(),
+	status: z.string().nullish(),
+	environment: z.string().nullish(),
+	release: z.string().nullish()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zTransactionsListResponse = z.object({
+	items: z.array(z.object({
+		duration_ms: z.number().nullable(),
+		environment: z.string(),
+		event_id: z.string(),
+		id: z.uuid(),
+		ingested_at: z.iso.datetime({ offset: true }),
+		platform: z.string(),
+		release: z.string(),
+		start_timestamp: z.iso.datetime({ offset: true }).nullable(),
+		timestamp: z.iso.datetime({ offset: true }),
+		transaction_name: z.string()
+	})),
+	page: z.int(),
+	per_page: z.int(),
+	total_count: z.int(),
+	total_pages: z.int()
+});
+const zTransactionsGetStatsPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zTransactionsGetStatsQuery = z.object({
+	page: z.int().gte(1).optional(),
+	per_page: z.int().gte(1).lte(100).optional()
+});
+/**
+* Offset-based paginated response wrapper
+*/
+const zTransactionsGetStatsResponse = z.object({
+	items: z.array(z.object({
+		count: z.int(),
+		failure_rate: z.number(),
+		op: z.string().nullable(),
+		p50_ms: z.number(),
+		p95_ms: z.number(),
+		p99_ms: z.number(),
+		transaction_name: z.string()
+	})),
+	page: z.int(),
+	per_page: z.int(),
+	total_count: z.int(),
+	total_pages: z.int()
+});
+const zTransactionsGetStatGroupPath = z.object({ project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }) });
+const zTransactionsGetStatGroupQuery = z.object({
+	name: z.string(),
+	op: z.string().nullish()
+});
+/**
+* Aggregate stats for one (transaction, op) group
+*/
+const zTransactionsGetStatGroupResponse = zTransactionStatsResponse;
+const zTransactionsGetPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	transaction_id: z.uuid()
+});
+/**
+* Full transaction detail
+*/
+const zTransactionsGetResponse = zTransactionDetailResponse;
+const zTransactionsGetSpansPath = z.object({
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	transaction_id: z.uuid()
+});
+/**
+* Indexed spans for the transaction (waterfall order)
+*/
+const zTransactionsGetSpansResponse = z.array(z.object({
+	description: z.string().nullable(),
+	duration_ms: z.number().nullable(),
+	environment: z.string().nullable(),
+	exclusive_time_ms: z.number().nullable(),
+	gen_ai_agent_name: z.string().nullable(),
+	gen_ai_conversation_id: z.string().nullable(),
+	gen_ai_operation_type: z.string().nullable(),
+	gen_ai_request_model: z.string().nullable(),
+	gen_ai_response_model: z.string().nullable(),
+	gen_ai_tool_name: z.string().nullable(),
+	gen_ai_usage_input_tokens: z.number().nullable(),
+	gen_ai_usage_output_tokens: z.number().nullable(),
+	gen_ai_usage_total_tokens: z.number().nullable(),
+	id: z.uuid(),
+	is_segment: z.boolean(),
+	op: z.string().nullable(),
+	parent_span_id: z.string().nullable(),
+	platform: z.string().nullable(),
+	release: z.string().nullable(),
+	segment_id: z.string().nullable(),
+	span_id: z.string().nullable(),
+	start_timestamp: z.iso.datetime({ offset: true }).nullable(),
+	status: z.string().nullable(),
+	timestamp: z.iso.datetime({ offset: true }).nullable(),
+	trace_id: z.string().nullable(),
+	transaction_id: z.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 = z.array(z.object({
+	estimated_bytes: z.int(),
+	events_bytes: z.int(),
+	events_count: z.int(),
+	logs_bytes: z.int(),
+	logs_count: z.int(),
+	project_id: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+	project_name: z.string(),
+	source_maps_count: z.int(),
+	spans_count: z.int(),
+	transactions_bytes: z.int(),
+	transactions_count: z.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 = z.array(zTeamMemberResponse);
+const zTeamDeleteUserPath = z.object({ user_id: z.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 = z.void();
+const zTeamUpdateRoleBody = zUpdateUserRole;
+const zTeamUpdateRolePath = z.object({ user_id: z.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 = z.void();
+/**
+* What the next heartbeat would carry
+*/
+const zTelemetryPreviewResponse = zTelemetryPreview;
+/**
+* List of tokens (masked)
+*/
+const zTokensListResponse = z.array(zAuthTokenResponse);
+const zTokensCreateBody = zCreateAuthToken;
+/**
+* Token created (full token shown once)
+*/
+const zTokensCreateResponse = zAuthTokenCreatedResponse;
+const zTokensDeletePath = z.object({ id: z.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 = z.void();
+const zTokensGetPath = z.object({ id: z.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 = z.object({ token: z.string() });
+/**
+* Invitation info
+*/
+const zAuthGetInvitationResponse = zInvitationInfoResponse;
+const zAuthLoginBody = zLoginRequest;
+/**
+* Logged in
+*/
+const zAuthLoginResponse = zAuthResponse;
+/**
+* Logged out
+*/
+const zAuthLogoutResponse = z.void();
+/**
+* Current user
+*/
+const zAuthGetCurrentUserResponse = zUserResponse;
+const zAuthUpdateCurrentUserBody = zUpdatePreferencesRequest;
+/**
+* Updated user
+*/
+const zAuthUpdateCurrentUserResponse = zUserResponse;
+const zAuthChangePasswordBody = zChangePasswordRequest;
+/**
+* Password changed
+*/
+const zAuthChangePasswordResponse = z.void();
+const zAuthRegisterBody = zCreateUserRequest;
+const zAuthSsoCallbackQuery = z.object({
+	code: z.string().nullish(),
+	state: z.string().nullish(),
+	error: z.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;
+//#endregion
+export { zAcceptInvitation, zActivityEntry, zAgentDurationPoint, zAgentModelRow, zAgentSummary, zAgentTimeseriesPoint, zAgentToolRow, zAgentsDurationPath, zAgentsDurationQuery, zAgentsDurationResponse, zAgentsEnvironmentsPath, zAgentsEnvironmentsResponse, zAgentsModelsCallsPath, zAgentsModelsCallsQuery, zAgentsModelsCallsResponse, zAgentsModelsTablePath, zAgentsModelsTableQuery, zAgentsModelsTableResponse, zAgentsModelsTokensPath, zAgentsModelsTokensQuery, zAgentsModelsTokensResponse, zAgentsRunsPath, zAgentsRunsQuery, zAgentsRunsResponse, zAgentsSummaryPath, zAgentsSummaryQuery, zAgentsSummaryResponse, zAgentsToolsPath, zAgentsToolsQuery, zAgentsToolsResponse, zAgentsToolsTablePath, zAgentsToolsTableQuery, zAgentsToolsTableResponse, zAgentsTracesPath, zAgentsTracesQuery, zAgentsTracesResponse, zAlertChannelsCreateBody, zAlertChannelsCreateResponse, zAlertChannelsDeletePath, zAlertChannelsDeleteResponse, zAlertChannelsGetPath, zAlertChannelsGetResponse, zAlertChannelsListResponse, zAlertChannelsPreviewTemplateBody, zAlertChannelsPreviewTemplateResponse, zAlertChannelsTestBody, zAlertChannelsTestPath, zAlertChannelsTestResponse, zAlertChannelsUpdateBody, zAlertChannelsUpdatePath, zAlertChannelsUpdateResponse, zAlertHistory, zAlertIntegration, zAlertRuleChannelInput, zAlertRuleResponse, zAlertRulesCreateBody, zAlertRulesCreatePath, zAlertRulesCreateResponse, zAlertRulesDeletePath, zAlertRulesDeleteResponse, zAlertRulesGetPath, zAlertRulesGetResponse, zAlertRulesListHistoryPath, zAlertRulesListHistoryQuery, zAlertRulesListHistoryResponse, zAlertRulesListPath, zAlertRulesListResponse, zAlertRulesUpdateBody, zAlertRulesUpdatePath, zAlertRulesUpdateResponse, zAlertStatus, zAlertType, zAssembleBody, zAssembleResponse, zAuthAcceptInvitationBody, zAuthAcceptInvitationResponse, zAuthChangePasswordBody, zAuthChangePasswordResponse, zAuthConfirmSsoLinkBody, zAuthConfirmSsoLinkResponse, zAuthGetCurrentUserResponse, zAuthGetInvitationPath, zAuthGetInvitationResponse, zAuthLoginBody, zAuthLoginResponse, zAuthLogoutResponse, zAuthRegisterBody, zAuthResponse, zAuthSsoCallbackQuery, zAuthSsoCallbackResponse, zAuthSsoConfigResponse, zAuthSsoLinkResponse, zAuthSsoStartResponse, zAuthTokenCreatedResponse, zAuthTokenResponse, zAuthUpdateCurrentUserBody, zAuthUpdateCurrentUserResponse, zAuthorizationDecision, zAuthorizationInfo, zAuthorizationRedirect, zAuthorizationRequest, zBookmarkResponse, zBulkDeleteIssues, zBulkDeleteResponse, zBulkUpdateIssues, zBulkUpdateResponse, zChangePasswordRequest, zCheckInResponse, zCheckInStatus, zChunkUploadBody, zChunkUploadOptions, zCleanupCounts, zCleanupFrequency, zCleanupRequest, zCleanupState, zCleanupStatus, zCodeMapping, zCommentRequest, zConfirmSsoLinkRequest, zCreateAlertIntegration, zCreateAlertRule, zCreateAuthToken, zCreateGitHubIssue, zCreateInvitation, zCreateMonitor, zCreateProject, zCreateRelease, zCreateUserRequest, zErrorDetail, zEventDetailResponse, zEventTimeseriesPoint, zEventsGetBySentryIdPath, zEventsGetBySentryIdResponse, zEventsGetPath, zEventsGetResponse, zEventsListPath, zEventsListQuery, zEventsListResponse, zFieldError, zFieldErrorCode, zGenAiBreakdownRow, zGitHubAppInfo, zGitHubInstallation, zGitHubLogin, zGitHubRepository, zGitHubStatus, zGithubCallbackQuery, zGithubCreateIssueBody, zGithubCreateIssuePath, zGithubCreateIssueResponse, zGithubDeleteProjectRepositoryPath, zGithubDeleteProjectRepositoryResponse, zGithubDisconnectResponse, zGithubGetMyLoginResponse, zGithubGetProjectRepositoryPath, zGithubGetProjectRepositoryResponse, zGithubInstalledQuery, zGithubIssuePath, zGithubIssueResponse, zGithubLinkIssueBody, zGithubLinkIssuePath, zGithubLinkIssueResponse, zGithubManifestBody, zGithubManifestResponse, zGithubPutMyLoginBody, zGithubPutMyLoginResponse, zGithubPutProjectRepositoryBody, zGithubPutProjectRepositoryPath, zGithubPutProjectRepositoryResponse, zGithubRepositoriesQuery, zGithubRepositoriesResponse, zGithubStatusResponse, zGithubSyncCodeownersPath, zGithubSyncCodeownersResponse, zGithubUnlinkIssuePath, zGithubUnlinkIssueResponse, zGithubWebhookBody, zGithubWebhookResponse, zGrouping, zHealthLivenessResponse, zHealthReadinessResponse, zHealthVersionResponse, zIntervalUnit, zInvitationInfoResponse, zInvitationResponse, zInvitationsCreateBody, zInvitationsCreateResponse, zInvitationsListResponse, zInvitationsRevokePath, zInvitationsRevokeResponse, zIssueAggregates, zIssueFilter, zIssueGitHub, zIssueLink, zIssuePriority, zIssueResponse, zIssueSort, zIssueStatsResponse, zIssueStatsWindow, zIssueStatus, zIssueStatusUpdate, zIssueTagValue, zIssuesBulkDeleteBody, zIssuesBulkDeletePath, zIssuesBulkDeleteResponse, zIssuesBulkUpdateBody, zIssuesBulkUpdatePath, zIssuesBulkUpdateResponse, zIssuesCreateCommentBody, zIssuesCreateCommentPath, zIssuesCreateCommentResponse, zIssuesCreateUserReportBody, zIssuesCreateUserReportPath, zIssuesCreateUserReportResponse, zIssuesDeletePath, zIssuesDeleteResponse, zIssuesGetActivityPath, zIssuesGetActivityResponse, zIssuesGetAggregatesPath, zIssuesGetAggregatesResponse, zIssuesGetHashesPath, zIssuesGetHashesResponse, zIssuesGetPath, zIssuesGetResponse, zIssuesGetStatsPath, zIssuesGetStatsQuery, zIssuesGetStatsResponse, zIssuesGetTagValuesPath, zIssuesGetTagValuesResponse, zIssuesListPath, zIssuesListQuery, zIssuesListResponse, zIssuesListUserReportsPath, zIssuesListUserReportsResponse, zIssuesMarkSeenPath, zIssuesMarkSeenResponse, zIssuesSetBookmarkBody, zIssuesSetBookmarkPath, zIssuesSetBookmarkResponse, zIssuesSetSubscriptionBody, zIssuesSetSubscriptionPath, zIssuesSetSubscriptionResponse, zIssuesUpdateBody, zIssuesUpdatePath, zIssuesUpdateResponse, zKindAge, zLinkGitHubIssue, zLivenessResponse, zLoginRequest, zLogsListPath, zLogsListQuery, zLogsListResponse, zManifestRequest, zManifestResponse, zMcpSettings, zMcpStatus, zMembersListPath, zMembersListResponse, zMembersRemovePath, zMembersRemoveResponse, zMembersUpsertBody, zMembersUpsertPath, zMembersUpsertResponse, zMetricDelta, zMonitorConfig, zMonitorConfigInput, zMonitorEnvironmentResponse, zMonitorEnvironmentStatus, zMonitorResponse, zMonitorsCreateBody, zMonitorsCreatePath, zMonitorsCreateResponse, zMonitorsDeletePath, zMonitorsDeleteResponse, zMonitorsGetPath, zMonitorsGetResponse, zMonitorsListCheckinsPath, zMonitorsListCheckinsQuery, zMonitorsListCheckinsResponse, zMonitorsListPath, zMonitorsListResponse, zMonitorsUpdateBody, zMonitorsUpdatePath, zMonitorsUpdateResponse, zOAuthGrant, zOauthDecideAuthorizationBody, zOauthDecideAuthorizationResponse, zOauthGetAuthorizationQuery, zOauthGetAuthorizationResponse, zOauthListGrantsResponse, zOauthRevokeGrantPath, zOauthRevokeGrantResponse, zOrgDetails, zPreviewSchedule, zPreviewTemplateBody, zPreviewTemplateResponse, zProjectAge, zProjectListStats, zProjectMember, zProjectMemberResponse, zProjectRepository, zProjectResponse, zProjectRetention, zProjectRole, zProjectStatsSummary, zProjectsCreateBody, zProjectsCreateResponse, zProjectsDeletePath, zProjectsDeleteResponse, zProjectsGetPath, zProjectsGetRateLimitsResponse, zProjectsGetResponse, zProjectsListQuery, zProjectsListResponse, zProjectsUpdateBody, zProjectsUpdatePath, zProjectsUpdateResponse, zProviderType, zRateLimitsResponse, zReadinessChecks, zReadinessResponse, zReleaseResponse, zReleasesCreateBody, zReleasesCreatePath, zReleasesCreateResponse, zReleasesFinalizeBody, zReleasesFinalizePath, zReleasesFinalizeResponse, zReleasesNewIssuesPath, zReleasesNewIssuesQuery, zReleasesNewIssuesResponse, zRepoCommit, zRetentionResponse, zRetentionRun, zRetentionSettings, zRetentionWindows, zSchedule, zSchedulePreview, zSchedulesPreviewBody, zSchedulesPreviewResponse, zSeenResponse, zSessionSummary, zSessionTimeseriesPoint, zSessionsGetStatsPath, zSessionsGetStatsQuery, zSessionsGetStatsResponse, zSessionsGetSummaryPath, zSessionsGetSummaryQuery, zSessionsGetSummaryResponse, zSessionsGetTimeseriesPath, zSessionsGetTimeseriesQuery, zSessionsGetTimeseriesResponse, zSettingsGetMcpResponse, zSettingsUpdateMcpBody, zSettingsUpdateMcpResponse, zSortOrder, zSourceMapFile, zSourceMapGcResult, zSourceMapList, zSourceMapStorage, zSourceMapsArtifactBundleAssembleBody, zSourceMapsArtifactBundleAssemblePath, zSourceMapsArtifactBundleAssembleResponse, zSourceMapsChunkUploadBody, zSourceMapsChunkUploadCapabilityPath, zSourceMapsChunkUploadCapabilityResponse, zSourceMapsChunkUploadPath, zSourceMapsListPath, zSourceMapsListResponse, zSourceMapsOrgDetailsPath, zSourceMapsOrgDetailsResponse, zSpanDetailResponse, zSpanResponse, zSpansGetPath, zSpansGetResponse, zSpansListPath, zSpansListQuery, zSpansListResponse, zSsoConfigResponse, zSsoLinkResponse, zSsoStartResponse, zStatsGetEventTimeseriesPath, zStatsGetEventTimeseriesQuery, zStatsGetEventTimeseriesResponse, zStatsGetSummaryPath, zStatsGetSummaryQuery, zStatsGetSummaryResponse, zStorageAge, zStorageExecuteCleanupBody, zStorageExecuteCleanupResponse, zStorageGcSourceMapsResponse, zStorageGetAgeResponse, zStorageGetCleanupStatusResponse, zStorageGetProjectsResponse, zStorageGetRetentionResponse, zStorageGetSummaryResponse, zStoragePreviewCleanupBody, zStoragePreviewCleanupResponse, zStoragePreviewRetentionBody, zStoragePreviewRetentionResponse, zStoragePreviewSourceMapGcResponse, zStorageRunRetentionResponse, zStorageSummary, zStorageUpdateRetentionBody, zStorageUpdateRetentionResponse, zSubscriptionResponse, zTagSummary, zTagValueCount, zTeamDeleteUserPath, zTeamDeleteUserResponse, zTeamListResponse, zTeamMemberResponse, zTeamUpdateRoleBody, zTeamUpdateRolePath, zTeamUpdateRoleResponse, zTelemetryPreview, zTelemetryPreviewResponse, zTestChannelResponse, zTestIntegrationBody, zToggleRequest, zTokensCreateBody, zTokensCreateResponse, zTokensDeletePath, zTokensDeleteResponse, zTokensGetPath, zTokensGetResponse, zTokensListResponse, zTransactionDetailResponse, zTransactionStatsResponse, zTransactionsGetPath, zTransactionsGetResponse, zTransactionsGetSpansPath, zTransactionsGetSpansResponse, zTransactionsGetStatGroupPath, zTransactionsGetStatGroupQuery, zTransactionsGetStatGroupResponse, zTransactionsGetStatsPath, zTransactionsGetStatsQuery, zTransactionsGetStatsResponse, zTransactionsListPath, zTransactionsListQuery, zTransactionsListResponse, zUpdateAlertIntegration, zUpdateAlertRule, zUpdateIssueState, zUpdateMonitor, zUpdatePreferencesRequest, zUpdateProject, zUpdateProjectRepository, zUpdateRelease, zUpdateUserRole, zUpsertProjectMember, zUserReport, zUserReportRequest, zUserResponse, zUserRole, zVersionResponse };
+
+//# sourceMappingURL=zod.gen.mjs.map