@rustrak/client 0.18.1 → 0.19.0

package/dist/generated/sdk.gen.cjs

@@ -0,0 +1,3138 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_bodySerializer_gen = require("./core/bodySerializer.gen.cjs");
+const require_client_gen = require("./client.gen.cjs");
+const require_zod_gen = require("./zod.gen.cjs");
+let zod = require("zod");
+zod = require_runtime.__toESM(zod, 1);
+//#region src/generated/sdk.gen.ts
+var HeyApiClient = class {
+	client;
+	constructor(args) {
+		this.client = args?.client ?? require_client_gen.client;
+	}
+};
+var HeyApiRegistry = class {
+	defaultKey = "default";
+	instances = /* @__PURE__ */ new Map();
+	get(key) {
+		const instance = this.instances.get(key ?? this.defaultKey);
+		if (!instance) throw new Error(`No SDK client found. Create one with "new Rustrak()" to fix this error.`);
+		return instance;
+	}
+	set(value, key) {
+		this.instances.set(key ?? this.defaultKey, value);
+	}
+};
+var SourceMaps = class extends HeyApiClient {
+	/**
+	* GET /api/0/organizations/{org_slug}/
+	* Always returns 200 with synthetic org data — sentry-cli validates this before uploading.
+	*/
+	orgDetails(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zSourceMapsOrgDetailsPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zSourceMapsOrgDetailsResponse.parseAsync(data),
+			url: "/api/0/organizations/{org_slug}/",
+			...options
+		});
+	}
+	/**
+	* POST /api/0/organizations/{org_slug}/artifactbundle/assemble/
+	*/
+	artifactBundleAssemble(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zSourceMapsArtifactBundleAssembleBody,
+				path: require_zod_gen.zSourceMapsArtifactBundleAssemblePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zSourceMapsArtifactBundleAssembleResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/0/organizations/{org_slug}/artifactbundle/assemble/",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* GET /api/0/organizations/{org_slug}/chunk-upload/
+	*/
+	chunkUploadCapability(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zSourceMapsChunkUploadCapabilityPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zSourceMapsChunkUploadCapabilityResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/0/organizations/{org_slug}/chunk-upload/",
+			...options
+		});
+	}
+	/**
+	* POST /api/0/organizations/{org_slug}/chunk-upload/
+	*/
+	chunkUpload(options) {
+		return (options.client ?? this.client).post({
+			...require_bodySerializer_gen.formDataBodySerializer,
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zSourceMapsChunkUploadBody,
+				path: require_zod_gen.zSourceMapsChunkUploadPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/0/organizations/{org_slug}/chunk-upload/",
+			...options,
+			headers: {
+				"Content-Type": null,
+				...options.headers
+			}
+		});
+	}
+	/**
+	* GET /api/0/projects/{org_slug}/{project_slug}/files/source-maps/
+	*/
+	list(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zSourceMapsListPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zSourceMapsListResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/0/projects/{org_slug}/{project_slug}/files/source-maps/",
+			...options
+		});
+	}
+};
+var Releases = class extends HeyApiClient {
+	/**
+	* POST /api/0/projects/{org_slug}/{project_slug}/releases/
+	*
+	* Sentry-compatible release creation. Idempotent: repeating the same
+	* `(project, version)` returns 208 rather than erroring — sentry-cli and JS
+	* bundler plugins call this on every build. Triggers date-based regression
+	* clearing (see [`crate::services::issue::IssueService::finalize_release`])
+	* on every call, not just the new-row branch: `finalize_release`'s own
+	* `UPDATE ... WHERE` is idempotent (a repeat run affects 0 rows once nothing
+	* is left to clear), so this also self-heals a prior call that created the
+	* row but failed before clearing ran — a plain `if created` gate would
+	* otherwise skip clearing forever once a retry lands on the 208 branch.
+	*/
+	create(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zReleasesCreateBody,
+				path: require_zod_gen.zReleasesCreatePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zReleasesCreateResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/0/projects/{org_slug}/{project_slug}/releases/",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* PUT /api/0/projects/{org_slug}/{project_slug}/releases/{version}/
+	*
+	* Generic partial update (`ref`, `url`, `dateReleased`). Setting
+	* `dateReleased` IS "finalize" — there is no separate status flag.
+	*/
+	finalize(options) {
+		return (options.client ?? this.client).put({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zReleasesFinalizeBody,
+				path: require_zod_gen.zReleasesFinalizePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zReleasesFinalizeResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/0/projects/{org_slug}/{project_slug}/releases/{version}/",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/releases/{release}/new-issues
+	*/
+	newIssues(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zReleasesNewIssuesPath,
+				query: require_zod_gen.zReleasesNewIssuesQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zReleasesNewIssuesResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/releases/{release}/new-issues",
+			...options
+		});
+	}
+};
+var Github = class extends HeyApiClient {
+	/**
+	* DELETE /api/github
+	*/
+	disconnect(options) {
+		return (options?.client ?? this.client).delete({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zGithubDisconnectResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/github",
+			...options
+		});
+	}
+	/**
+	* GET /api/github
+	*/
+	status(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zGithubStatusResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/github",
+			...options
+		});
+	}
+	/**
+	* GET /api/github/callback: GitHub sends the browser here after creating the
+	* app; the code trades for its credentials.
+	*/
+	callback(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: require_zod_gen.zGithubCallbackQuery
+			}).parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/github/callback",
+			...options
+		});
+	}
+	/**
+	* GET /api/github/installed: GitHub sends the browser here after the app is
+	* installed on an account.
+	*/
+	installed(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: require_zod_gen.zGithubInstalledQuery
+			}).parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/github/installed",
+			...options
+		});
+	}
+	/**
+	* POST /api/github/manifest: what the dashboard posts to GitHub so GitHub
+	* creates an app already configured for this server.
+	*/
+	manifest(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zGithubManifestBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zGithubManifestResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/github/manifest",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* GET /api/github/me: the GitHub username assignees sync through.
+	*/
+	getMyLogin(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zGithubGetMyLoginResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/github/me",
+			...options
+		});
+	}
+	/**
+	* PUT /api/github/me
+	*/
+	putMyLogin(options) {
+		return (options.client ?? this.client).put({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zGithubPutMyLoginBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zGithubPutMyLoginResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/github/me",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* GET /api/github/repositories?project_id=: the repositories a project can
+	* point at, for whoever may change that project's settings.
+	*/
+	repositories(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: require_zod_gen.zGithubRepositoriesQuery
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zGithubRepositoriesResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/github/repositories",
+			...options
+		});
+	}
+	/**
+	* POST /api/github/webhook: public, and trusted only through the signature
+	* GitHub computes with the app's webhook secret.
+	*/
+	webhook(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zGithubWebhookBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zGithubWebhookResponse.parseAsync(data),
+			url: "/api/github/webhook",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* DELETE /api/projects/{project_id}/github
+	*/
+	deleteProjectRepository(options) {
+		return (options.client ?? this.client).delete({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zGithubDeleteProjectRepositoryPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zGithubDeleteProjectRepositoryResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/github",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/github
+	*/
+	getProjectRepository(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zGithubGetProjectRepositoryPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zGithubGetProjectRepositoryResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/github",
+			...options
+		});
+	}
+	/**
+	* PUT /api/projects/{project_id}/github
+	*/
+	putProjectRepository(options) {
+		return (options.client ?? this.client).put({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zGithubPutProjectRepositoryBody,
+				path: require_zod_gen.zGithubPutProjectRepositoryPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zGithubPutProjectRepositoryResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/github",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* POST /api/projects/{project_id}/github/codeowners: copies the repository's
+	* CODEOWNERS so ownership can be answered without asking GitHub each time.
+	*/
+	syncCodeowners(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zGithubSyncCodeownersPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zGithubSyncCodeownersResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/github/codeowners",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/issues/{issue_id}/github: the issue's links,
+	* the commits that may have caused it, and who owns its culprit file.
+	*/
+	issue(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zGithubIssuePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zGithubIssueResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/github",
+			...options
+		});
+	}
+	/**
+	* POST .../github/issues: opens a GitHub issue and links it.
+	*/
+	createIssue(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zGithubCreateIssueBody,
+				path: require_zod_gen.zGithubCreateIssuePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zGithubCreateIssueResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/github/issues",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* POST .../github/links: links an existing GitHub issue or pull request.
+	*/
+	linkIssue(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zGithubLinkIssueBody,
+				path: require_zod_gen.zGithubLinkIssuePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zGithubLinkIssueResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/github/links",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* DELETE .../github/links/{link_id}
+	*/
+	unlinkIssue(options) {
+		return (options.client ?? this.client).delete({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zGithubUnlinkIssuePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zGithubUnlinkIssueResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/github/links/{link_id}",
+			...options
+		});
+	}
+};
+var AlertChannels = class extends HeyApiClient {
+	/**
+	* GET /api/alert-channels
+	*/
+	list(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAlertChannelsListResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/integrations",
+			...options
+		});
+	}
+	/**
+	* POST /api/alert-channels
+	*/
+	create(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zAlertChannelsCreateBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAlertChannelsCreateResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/integrations",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* POST /api/integrations/preview-template
+	*
+	* Renders a Custom Webhook template against a sample payload and hands back
+	* the body that would be sent. The dashboard cannot run the template engine,
+	* so it asks while the reader types; going through the dispatcher's own
+	* renderer is what keeps the preview from disagreeing with a delivery.
+	*/
+	previewTemplate(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zAlertChannelsPreviewTemplateBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAlertChannelsPreviewTemplateResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/integrations/preview-template",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* DELETE /api/alert-channels/{id}
+	*/
+	delete(options) {
+		return (options.client ?? this.client).delete({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAlertChannelsDeletePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAlertChannelsDeleteResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/integrations/{id}",
+			...options
+		});
+	}
+	/**
+	* GET /api/alert-channels/{id}
+	*/
+	get(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAlertChannelsGetPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAlertChannelsGetResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/integrations/{id}",
+			...options
+		});
+	}
+	/**
+	* PATCH /api/alert-channels/{id}
+	*/
+	update(options) {
+		return (options.client ?? this.client).patch({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zAlertChannelsUpdateBody,
+				path: require_zod_gen.zAlertChannelsUpdatePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAlertChannelsUpdateResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/integrations/{id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* POST /api/integrations/{id}/test
+	*/
+	test(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zAlertChannelsTestBody.optional(),
+				path: require_zod_gen.zAlertChannelsTestPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAlertChannelsTestResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/integrations/{id}/test",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Invitations = class extends HeyApiClient {
+	/**
+	* GET /api/invitations — list invitations (admin only)
+	*/
+	list(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zInvitationsListResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/invitations",
+			...options
+		});
+	}
+	/**
+	* POST /api/invitations — create an invitation (admin only)
+	*/
+	create(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zInvitationsCreateBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zInvitationsCreateResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/invitations",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* DELETE /api/invitations/{token} — revoke a pending invitation (admin only)
+	*/
+	revoke(options) {
+		return (options.client ?? this.client).delete({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zInvitationsRevokePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zInvitationsRevokeResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/invitations/{token}",
+			...options
+		});
+	}
+};
+var Oauth = class extends HeyApiClient {
+	/**
+	* Verifies an authorization request and says who is asking.
+	*/
+	getAuthorization(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: require_zod_gen.zOauthGetAuthorizationQuery
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zOauthGetAuthorizationResponse.parseAsync(data),
+			url: "/api/oauth/authorize",
+			...options
+		});
+	}
+	/**
+	* Approves or denies an authorization request as the signed-in user.
+	*/
+	decideAuthorization(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zOauthDecideAuthorizationBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zOauthDecideAuthorizationResponse.parseAsync(data),
+			url: "/api/oauth/authorize",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Lists the assistants connected to the signed-in user's account.
+	*/
+	listGrants(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zOauthListGrantsResponse.parseAsync(data),
+			url: "/api/oauth/grants",
+			...options
+		});
+	}
+	/**
+	* Disconnects an assistant: its tokens stop working at once.
+	*/
+	revokeGrant(options) {
+		return (options.client ?? this.client).delete({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zOauthRevokeGrantPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zOauthRevokeGrantResponse.parseAsync(data),
+			url: "/api/oauth/grants/{id}",
+			...options
+		});
+	}
+};
+var Projects = class extends HeyApiClient {
+	/**
+	* GET /api/projects - List projects with pagination
+	*
+	* Admins see every project. Non-admins see only the projects they belong to.
+	*/
+	list(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: require_zod_gen.zProjectsListQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zProjectsListResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects",
+			...options
+		});
+	}
+	/**
+	* POST /api/projects - Create a new project
+	*
+	* Any authenticated user may create a project. A non-admin creator is
+	* automatically granted the project `admin` role so they can access it.
+	*/
+	create(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zProjectsCreateBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zProjectsCreateResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* DELETE /api/projects/{id} - Delete a project
+	*/
+	delete(options) {
+		return (options.client ?? this.client).delete({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zProjectsDeletePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zProjectsDeleteResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{id}",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{id} - Get a project by ID
+	*/
+	get(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zProjectsGetPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zProjectsGetResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{id}",
+			...options
+		});
+	}
+	/**
+	* PATCH /api/projects/{id} - Update a project
+	*/
+	update(options) {
+		return (options.client ?? this.client).patch({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zProjectsUpdateBody,
+				path: require_zod_gen.zProjectsUpdatePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zProjectsUpdateResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* GET /api/rate-limits - What a project without limits of its own follows
+	*/
+	getRateLimits(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zProjectsGetRateLimitsResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/rate-limits",
+			...options
+		});
+	}
+};
+var Agents = class extends HeyApiClient {
+	/**
+	* GET /api/projects/{project_id}/agents/duration
+	* Time-bucketed avg/p95 duration for `agent`/`ai_client` spans.
+	*/
+	duration(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAgentsDurationPath,
+				query: require_zod_gen.zAgentsDurationQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAgentsDurationResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/agents/duration",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/agents/environments
+	* The options the environment filter offers, read from the data rather than
+	* hardcoded — an installation may name its environments anything.
+	*/
+	environments(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAgentsEnvironmentsPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAgentsEnvironmentsResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/agents/environments",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/agents/models
+	*/
+	modelsTable(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAgentsModelsTablePath,
+				query: require_zod_gen.zAgentsModelsTableQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAgentsModelsTableResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/agents/models",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/agents/models/calls
+	* Top models by LLM call count (`gen_ai.operation.type:ai_client`).
+	*/
+	modelsCalls(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAgentsModelsCallsPath,
+				query: require_zod_gen.zAgentsModelsCallsQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAgentsModelsCallsResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/agents/models/calls",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/agents/models/tokens
+	* Top models by total tokens used (`gen_ai.operation.type:ai_client`).
+	*/
+	modelsTokens(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAgentsModelsTokensPath,
+				query: require_zod_gen.zAgentsModelsTokensQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAgentsModelsTokensResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/agents/models/tokens",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/agents/runs
+	* Time-bucketed count of agent-run spans (`gen_ai.operation.type:agent`).
+	*/
+	runs(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAgentsRunsPath,
+				query: require_zod_gen.zAgentsRunsQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAgentsRunsResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/agents/runs",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/agents/summary
+	* Agent runs, LLM calls, tool calls, errors, tokens and latency over the
+	* selected window — the numbers the six charts cannot state outright.
+	*/
+	summary(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAgentsSummaryPath,
+				query: require_zod_gen.zAgentsSummaryQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAgentsSummaryResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/agents/summary",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/agents/tools
+	* Top tools by call count (`gen_ai.operation.type:tool`).
+	*/
+	tools(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAgentsToolsPath,
+				query: require_zod_gen.zAgentsToolsQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAgentsToolsResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/agents/tools",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/agents/tools/stats
+	*/
+	toolsTable(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAgentsToolsTablePath,
+				query: require_zod_gen.zAgentsToolsTableQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAgentsToolsTableResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/agents/tools/stats",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/agents/traces
+	* Paginated per-trace_id aggregate (duration, tokens, tool usage) across
+	* all AI spans sharing that trace, regardless of origin.
+	*/
+	traces(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAgentsTracesPath,
+				query: require_zod_gen.zAgentsTracesQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAgentsTracesResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/agents/traces",
+			...options
+		});
+	}
+};
+var AlertRules = class extends HeyApiClient {
+	/**
+	* GET /api/projects/{project_id}/alert-history
+	*/
+	listHistory(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAlertRulesListHistoryPath,
+				query: require_zod_gen.zAlertRulesListHistoryQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAlertRulesListHistoryResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/alert-history",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/alert-rules
+	*/
+	list(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAlertRulesListPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAlertRulesListResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/alert-rules",
+			...options
+		});
+	}
+	/**
+	* POST /api/projects/{project_id}/alert-rules
+	*/
+	create(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zAlertRulesCreateBody,
+				path: require_zod_gen.zAlertRulesCreatePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAlertRulesCreateResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/alert-rules",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* DELETE /api/projects/{project_id}/alert-rules/{rule_id}
+	*/
+	delete(options) {
+		return (options.client ?? this.client).delete({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAlertRulesDeletePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAlertRulesDeleteResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/alert-rules/{rule_id}",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/alert-rules/{rule_id}
+	*/
+	get(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAlertRulesGetPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAlertRulesGetResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/alert-rules/{rule_id}",
+			...options
+		});
+	}
+	/**
+	* PATCH /api/projects/{project_id}/alert-rules/{rule_id}
+	*/
+	update(options) {
+		return (options.client ?? this.client).patch({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zAlertRulesUpdateBody,
+				path: require_zod_gen.zAlertRulesUpdatePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAlertRulesUpdateResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/alert-rules/{rule_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Events = class extends HeyApiClient {
+	/**
+	* Resolve the ID returned by a Sentry SDK without already knowing the issue.
+	*/
+	getBySentryId(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zEventsGetBySentryIdPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zEventsGetBySentryIdResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/events/sentry/{event_id}",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/issues/{issue_id}/events
+	* Lists events for an issue with cursor-based pagination
+	*/
+	list(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zEventsListPath,
+				query: require_zod_gen.zEventsListQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zEventsListResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/events",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/issues/{issue_id}/events/{event_id}
+	* Gets a single event with full data
+	*/
+	get(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zEventsGetPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zEventsGetResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/events/{event_id}",
+			...options
+		});
+	}
+};
+var Stats = class extends HeyApiClient {
+	/**
+	* GET /api/projects/{project_id}/events/stats
+	*/
+	getEventTimeseries(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zStatsGetEventTimeseriesPath,
+				query: require_zod_gen.zStatsGetEventTimeseriesQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zStatsGetEventTimeseriesResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/events/stats",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/stats/summary
+	*/
+	getSummary(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zStatsGetSummaryPath,
+				query: require_zod_gen.zStatsGetSummaryQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zStatsGetSummaryResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/stats/summary",
+			...options
+		});
+	}
+};
+var Issues = class extends HeyApiClient {
+	/**
+	* DELETE /api/projects/{project_id}/issues  (bulk delete by ids or filter)
+	*/
+	bulkDelete(options) {
+		return (options.client ?? this.client).delete({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zIssuesBulkDeleteBody,
+				path: require_zod_gen.zIssuesBulkDeletePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesBulkDeleteResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/issues
+	* Lists issues for a project with offset-based pagination
+	*/
+	list(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zIssuesListPath,
+				query: require_zod_gen.zIssuesListQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesListResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues",
+			...options
+		});
+	}
+	/**
+	* PUT /api/projects/{project_id}/issues  (bulk mutate)
+	*/
+	bulkUpdate(options) {
+		return (options.client ?? this.client).put({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zIssuesBulkUpdateBody,
+				path: require_zod_gen.zIssuesBulkUpdatePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesBulkUpdateResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* DELETE /api/projects/{project_id}/issues/{issue_id}
+	* Hard-deletes an issue and all associated events
+	*/
+	delete(options) {
+		return (options.client ?? this.client).delete({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zIssuesDeletePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesDeleteResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/issues/{issue_id}
+	* Gets a single issue by ID
+	*/
+	get(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zIssuesGetPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesGetResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}",
+			...options
+		});
+	}
+	/**
+	* PATCH /api/projects/{project_id}/issues/{issue_id}
+	* Updates issue state (resolve, mute, etc.)
+	*/
+	update(options) {
+		return (options.client ?? this.client).patch({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zIssuesUpdateBody,
+				path: require_zod_gen.zIssuesUpdatePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesUpdateResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* GET /{issue_id}/activity — chronological activity log (incl. comments).
+	*/
+	getActivity(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zIssuesGetActivityPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesGetActivityResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/activity",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/issues/{issue_id}/aggregates
+	* Returns the unique user count and top tags for the issue.
+	*/
+	getAggregates(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zIssuesGetAggregatesPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesGetAggregatesResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/aggregates",
+			...options
+		});
+	}
+	/**
+	* PUT /{issue_id}/bookmark — set/clear the per-user bookmark.
+	*/
+	setBookmark(options) {
+		return (options.client ?? this.client).put({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zIssuesSetBookmarkBody,
+				path: require_zod_gen.zIssuesSetBookmarkPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesSetBookmarkResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/bookmark",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* POST /{issue_id}/comments — add a note.
+	*/
+	createComment(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zIssuesCreateCommentBody,
+				path: require_zod_gen.zIssuesCreateCommentPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesCreateCommentResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/comments",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/issues/{issue_id}/hashes
+	* Lists the grouping hashes that map to an issue.
+	*/
+	getHashes(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zIssuesGetHashesPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesGetHashesResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/hashes",
+			...options
+		});
+	}
+	/**
+	* POST /{issue_id}/seen — mark the issue as seen by the current user.
+	*/
+	markSeen(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zIssuesMarkSeenPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesMarkSeenResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/seen",
+			...options
+		});
+	}
+	/**
+	* GET /{issue_id}/stats?window=24h|30d — zero-filled event-count timeseries.
+	*/
+	getStats(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zIssuesGetStatsPath,
+				query: require_zod_gen.zIssuesGetStatsQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesGetStatsResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/stats",
+			...options
+		});
+	}
+	/**
+	* PUT /{issue_id}/subscription — set/clear the per-user subscription.
+	*/
+	setSubscription(options) {
+		return (options.client ?? this.client).put({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zIssuesSetSubscriptionBody,
+				path: require_zod_gen.zIssuesSetSubscriptionPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesSetSubscriptionResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/subscription",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/issues/{issue_id}/tags/{key}
+	* Lists the distinct values (with counts) for a tag key across the issue.
+	*/
+	getTagValues(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zIssuesGetTagValuesPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesGetTagValuesResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/tags/{key}",
+			...options
+		});
+	}
+	/**
+	* GET /{issue_id}/user-reports — list user feedback for an issue.
+	*/
+	listUserReports(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zIssuesListUserReportsPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesListUserReportsResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/user-reports",
+			...options
+		});
+	}
+	/**
+	* POST /{issue_id}/user-reports — attach user feedback to an issue.
+	*/
+	createUserReport(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zIssuesCreateUserReportBody,
+				path: require_zod_gen.zIssuesCreateUserReportPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zIssuesCreateUserReportResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/issues/{issue_id}/user-reports",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Logs = class extends HeyApiClient {
+	/**
+	* GET /api/projects/{project_id}/logs
+	* Lists logs for a project with offset-based pagination (newest first by
+	* log timestamp), optionally filtered by level/trace_id.
+	*/
+	list(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zLogsListPath,
+				query: require_zod_gen.zLogsListQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zLogsListResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/logs",
+			...options
+		});
+	}
+};
+var Members = class extends HeyApiClient {
+	/**
+	* GET /api/projects/{project_id}/members
+	*/
+	list(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zMembersListPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zMembersListResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/members",
+			...options
+		});
+	}
+	/**
+	* PUT /api/projects/{project_id}/members
+	*/
+	upsert(options) {
+		return (options.client ?? this.client).put({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zMembersUpsertBody,
+				path: require_zod_gen.zMembersUpsertPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zMembersUpsertResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/members",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* DELETE /api/projects/{project_id}/members/{user_id}
+	*/
+	remove(options) {
+		return (options.client ?? this.client).delete({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zMembersRemovePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zMembersRemoveResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/members/{user_id}",
+			...options
+		});
+	}
+};
+var Monitors = class extends HeyApiClient {
+	/**
+	* GET /api/projects/{project_id}/monitors
+	*/
+	list(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zMonitorsListPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zMonitorsListResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/monitors",
+			...options
+		});
+	}
+	/**
+	* POST /api/projects/{project_id}/monitors
+	*/
+	create(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zMonitorsCreateBody,
+				path: require_zod_gen.zMonitorsCreatePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zMonitorsCreateResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/monitors",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* DELETE /api/projects/{project_id}/monitors/{slug}
+	*/
+	delete(options) {
+		return (options.client ?? this.client).delete({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zMonitorsDeletePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zMonitorsDeleteResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/monitors/{slug}",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/monitors/{slug}
+	*/
+	get(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zMonitorsGetPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zMonitorsGetResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/monitors/{slug}",
+			...options
+		});
+	}
+	/**
+	* PUT /api/projects/{project_id}/monitors/{slug}
+	*/
+	update(options) {
+		return (options.client ?? this.client).put({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zMonitorsUpdateBody,
+				path: require_zod_gen.zMonitorsUpdatePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zMonitorsUpdateResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/monitors/{slug}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/monitors/{slug}/checkins
+	*/
+	listCheckins(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zMonitorsListCheckinsPath,
+				query: require_zod_gen.zMonitorsListCheckinsQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zMonitorsListCheckinsResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/monitors/{slug}/checkins",
+			...options
+		});
+	}
+};
+var Sessions = class extends HeyApiClient {
+	/**
+	* GET /api/projects/{project_id}/sessions/stats
+	*/
+	getStats(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zSessionsGetStatsPath,
+				query: require_zod_gen.zSessionsGetStatsQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zSessionsGetStatsResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/sessions/stats",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/sessions/summary
+	*/
+	getSummary(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zSessionsGetSummaryPath,
+				query: require_zod_gen.zSessionsGetSummaryQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zSessionsGetSummaryResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/sessions/summary",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/sessions/timeseries
+	*/
+	getTimeseries(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zSessionsGetTimeseriesPath,
+				query: require_zod_gen.zSessionsGetTimeseriesQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zSessionsGetTimeseriesResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/sessions/timeseries",
+			...options
+		});
+	}
+};
+var Spans = class extends HeyApiClient {
+	/**
+	* GET /api/projects/{project_id}/spans
+	* Lists spans for a project with offset-based pagination (newest by
+	* start_timestamp first), optionally filtered by op/status/trace_id.
+	* Returns spans regardless of origin — standalone or extracted from a
+	* transaction — since both are stored in the same table.
+	*/
+	list(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zSpansListPath,
+				query: require_zod_gen.zSpansListQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zSpansListResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/spans",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/spans/{span_id}
+	* Returns one span together with its attributes and tags — the `gen_ai.*`
+	* payload (prompts, responses, tool arguments and results) that the list
+	* response deliberately omits, since `spans.data` is untrimmed and a whole
+	* trace's worth of it would dwarf the waterfall it is drawn from.
+	*/
+	get(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zSpansGetPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zSpansGetResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/spans/{span_id}",
+			...options
+		});
+	}
+};
+var Transactions = class extends HeyApiClient {
+	/**
+	* GET /api/projects/{project_id}/transactions
+	* Lists transactions for a project with offset-based pagination (newest first).
+	*/
+	list(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zTransactionsListPath,
+				query: require_zod_gen.zTransactionsListQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zTransactionsListResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/transactions",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/transactions/stats
+	* Returns paginated aggregate performance stats (count, p50/p95/p99 latency,
+	* failure rate) grouped by transaction name + op, most frequent first.
+	*/
+	getStats(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zTransactionsGetStatsPath,
+				query: require_zod_gen.zTransactionsGetStatsQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zTransactionsGetStatsResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/transactions/stats",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/transactions/stats/group?name=&op=
+	* Returns the aggregate stats for a single transaction group — a direct lookup
+	* so the summary header works regardless of how many groups the project has.
+	*/
+	getStatGroup(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zTransactionsGetStatGroupPath,
+				query: require_zod_gen.zTransactionsGetStatGroupQuery
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zTransactionsGetStatGroupResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/transactions/stats/group",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/transactions/{transaction_id}
+	* Returns a single transaction with its full Sentry payload (spans, contexts,
+	* measurements, tags) for the performance detail view.
+	*/
+	get(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zTransactionsGetPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zTransactionsGetResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/transactions/{transaction_id}",
+			...options
+		});
+	}
+	/**
+	* GET /api/projects/{project_id}/transactions/{transaction_id}/spans
+	* Returns the indexed spans extracted from a transaction, ordered for the
+	* waterfall view (by start_timestamp ascending).
+	*/
+	getSpans(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zTransactionsGetSpansPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zTransactionsGetSpansResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/projects/{project_id}/transactions/{transaction_id}/spans",
+			...options
+		});
+	}
+};
+var Schedules = class extends HeyApiClient {
+	/**
+	* POST /api/schedules/preview
+	*
+	* Validates a schedule and lists its next five runs from now, so no client
+	* ever parses a crontab itself.
+	*/
+	preview(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zSchedulesPreviewBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zSchedulesPreviewResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/schedules/preview",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Settings = class extends HeyApiClient {
+	/**
+	* Whether the MCP endpoint at `/mcp` is on.
+	*/
+	getMcp(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zSettingsGetMcpResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/settings/mcp",
+			...options
+		});
+	}
+	/**
+	* Turns the MCP endpoint at `/mcp` on or off. Instance admins only.
+	*/
+	updateMcp(options) {
+		return (options.client ?? this.client).put({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zSettingsUpdateMcpBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zSettingsUpdateMcpResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/settings/mcp",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Storage = class extends HeyApiClient {
+	/**
+	* GET /api/storage/age — rows per age bucket, per project and kind.
+	*/
+	getAge(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zStorageGetAgeResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/storage/age",
+			...options
+		});
+	}
+	/**
+	* POST /api/storage/cleanup — starts deleting old data and the issues it
+	* empties. Returns at once: the purge runs detached, in batches, and
+	* `GET /api/storage/cleanup/status` reports its progress.
+	*/
+	executeCleanup(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zStorageExecuteCleanupBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zStorageExecuteCleanupResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/storage/cleanup",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* POST /api/storage/cleanup/preview — dry-run count, mutates nothing.
+	*/
+	previewCleanup(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zStoragePreviewCleanupBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zStoragePreviewCleanupResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/storage/cleanup/preview",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* GET /api/storage/cleanup/status — progress of the running cleanup, or the
+	* outcome of the last one.
+	*/
+	getCleanupStatus(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zStorageGetCleanupStatusResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/storage/cleanup/status",
+			...options
+		});
+	}
+	/**
+	* GET /api/storage/projects — per-project counts and estimated weight.
+	*/
+	getProjects(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zStorageGetProjectsResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/storage/projects",
+			...options
+		});
+	}
+	/**
+	* GET /api/storage/retention
+	*/
+	getRetention(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zStorageGetRetentionResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/storage/retention",
+			...options
+		});
+	}
+	/**
+	* PUT /api/storage/retention
+	*/
+	updateRetention(options) {
+		return (options.client ?? this.client).put({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zStorageUpdateRetentionBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zStorageUpdateRetentionResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/storage/retention",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* POST /api/storage/retention/preview — what saving these settings would
+	* delete on the next cleanup, without saving or deleting anything.
+	*/
+	previewRetention(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zStoragePreviewRetentionBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zStoragePreviewRetentionResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/storage/retention/preview",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* POST /api/storage/retention/run — enforces the saved retention now,
+	* without waiting for the schedule. Follow it with the cleanup status.
+	*/
+	runRetention(options) {
+		return (options?.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zStorageRunRetentionResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/storage/retention/run",
+			...options
+		});
+	}
+	/**
+	* POST /api/storage/source-maps/gc — delete orphaned source maps (DB + disk).
+	*/
+	gcSourceMaps(options) {
+		return (options?.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zStorageGcSourceMapsResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/storage/source-maps/gc",
+			...options
+		});
+	}
+	/**
+	* POST /api/storage/source-maps/gc/preview — dry-run orphan count, deletes nothing.
+	*/
+	previewSourceMapGc(options) {
+		return (options?.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zStoragePreviewSourceMapGcResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/storage/source-maps/gc/preview",
+			...options
+		});
+	}
+	/**
+	* GET /api/storage/summary — row counts, DB size, and source-map weight.
+	*/
+	getSummary(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zStorageGetSummaryResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/storage/summary",
+			...options
+		});
+	}
+};
+var Team = class extends HeyApiClient {
+	/**
+	* GET /api/team — list all users (admin only)
+	*/
+	list(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zTeamListResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/team",
+			...options
+		});
+	}
+	/**
+	* DELETE /api/team/{user_id} — remove a user from the instance (admin only)
+	*/
+	deleteUser(options) {
+		return (options.client ?? this.client).delete({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zTeamDeleteUserPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zTeamDeleteUserResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/team/{user_id}",
+			...options
+		});
+	}
+	/**
+	* PATCH /api/team/{user_id}/role — change a user's global role (admin only)
+	*/
+	updateRole(options) {
+		return (options.client ?? this.client).patch({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zTeamUpdateRoleBody,
+				path: require_zod_gen.zTeamUpdateRolePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zTeamUpdateRoleResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/team/{user_id}/role",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Telemetry = class extends HeyApiClient {
+	/**
+	* GET /api/telemetry/preview
+	*/
+	preview(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zTelemetryPreviewResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/telemetry/preview",
+			...options
+		});
+	}
+};
+var Tokens = class extends HeyApiClient {
+	/**
+	* GET /api/tokens - List tokens (masked)
+	*
+	* Admins see all tokens; non-admins see only the tokens they own.
+	*/
+	list(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zTokensListResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/tokens",
+			...options
+		});
+	}
+	/**
+	* POST /api/tokens - Create a new token (scoped to the acting user)
+	*/
+	create(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zTokensCreateBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zTokensCreateResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/tokens",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* DELETE /api/tokens/{id} - Revoke a token
+	*
+	* Admins may revoke any token; non-admins may only revoke their own.
+	*/
+	delete(options) {
+		return (options.client ?? this.client).delete({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zTokensDeletePath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zTokensDeleteResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/tokens/{id}",
+			...options
+		});
+	}
+	/**
+	* GET /api/tokens/{id} - Reveal full token value
+	*
+	* Returns the complete token string. Admins may view any token;
+	* non-admins may only view their own.
+	*/
+	get(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zTokensGetPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zTokensGetResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/tokens/{id}",
+			...options
+		});
+	}
+};
+var Auth = class extends HeyApiClient {
+	/**
+	* POST /auth/accept-invitation
+	* Accept a pending invitation: creates the user (with the invite's email + role) and logs in.
+	*/
+	acceptInvitation(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zAuthAcceptInvitationBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAuthAcceptInvitationResponse.parseAsync(data),
+			url: "/auth/accept-invitation",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* GET /auth/invitation/{token}
+	* Returns the invitation's details if it is still acceptable (for the accept page).
+	*/
+	getInvitation(options) {
+		return (options.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: require_zod_gen.zAuthGetInvitationPath,
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAuthGetInvitationResponse.parseAsync(data),
+			url: "/auth/invitation/{token}",
+			...options
+		});
+	}
+	/**
+	* POST /auth/login
+	* Authenticate user and create session
+	*/
+	login(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zAuthLoginBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAuthLoginResponse.parseAsync(data),
+			url: "/auth/login",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* POST /auth/logout
+	* Clear session
+	*/
+	logout(options) {
+		return (options?.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAuthLogoutResponse.parseAsync(data),
+			security: [{
+				in: "cookie",
+				name: "session",
+				type: "apiKey"
+			}],
+			url: "/auth/logout",
+			...options
+		});
+	}
+	/**
+	* GET /auth/me
+	* Get current authenticated user
+	*/
+	getCurrentUser(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAuthGetCurrentUserResponse.parseAsync(data),
+			security: [{
+				in: "cookie",
+				name: "session",
+				type: "apiKey"
+			}],
+			url: "/auth/me",
+			...options
+		});
+	}
+	/**
+	* PATCH /auth/me
+	* Update the current user's presentation preferences
+	*/
+	updateCurrentUser(options) {
+		return (options.client ?? this.client).patch({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zAuthUpdateCurrentUserBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAuthUpdateCurrentUserResponse.parseAsync(data),
+			security: [{
+				in: "cookie",
+				name: "session",
+				type: "apiKey"
+			}],
+			url: "/auth/me",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* POST /auth/me/password
+	* Change the current user's password
+	*/
+	changePassword(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zAuthChangePasswordBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAuthChangePasswordResponse.parseAsync(data),
+			security: [{
+				in: "cookie",
+				name: "session",
+				type: "apiKey"
+			}],
+			url: "/auth/me/password",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* POST /auth/register
+	* Registration is invite-only — always rejected. Use `/auth/accept-invitation`.
+	*/
+	register(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zAuthRegisterBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			url: "/auth/register",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* GET /auth/sso/callback
+	* Validate the provider response, resolve or provision the local account, and
+	* establish the normal Rustrak session.
+	*/
+	ssoCallback(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: require_zod_gen.zAuthSsoCallbackQuery.optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAuthSsoCallbackResponse.parseAsync(data),
+			url: "/auth/sso/callback",
+			...options
+		});
+	}
+	/**
+	* GET /auth/sso/config
+	* Public, non-sensitive information used to render the login page.
+	*/
+	ssoConfig(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAuthSsoConfigResponse.parseAsync(data),
+			url: "/auth/sso/config",
+			...options
+		});
+	}
+	/**
+	* GET /auth/sso/link
+	* The account an SSO login matched, shown while its owner confirms.
+	*/
+	ssoLink(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAuthSsoLinkResponse.parseAsync(data),
+			url: "/auth/sso/link",
+			...options
+		});
+	}
+	/**
+	* POST /auth/sso/link
+	* Link the pending SSO identity to its account once the account's password
+	* is given, and sign in. A wrong password keeps the link pending for a retry.
+	*/
+	confirmSsoLink(options) {
+		return (options.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: require_zod_gen.zAuthConfirmSsoLinkBody,
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAuthConfirmSsoLinkResponse.parseAsync(data),
+			url: "/auth/sso/link",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* POST /auth/sso/start
+	* Create a one-time OIDC authorization request and retain its protections in
+	* the encrypted session cookie.
+	*/
+	ssoStart(options) {
+		return (options?.client ?? this.client).post({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zAuthSsoStartResponse.parseAsync(data),
+			url: "/auth/sso/start",
+			...options
+		});
+	}
+};
+var Health = class extends HeyApiClient {
+	/**
+	* Liveness check - is the process running?
+	* Returns 200 if the server is alive.
+	*/
+	liveness(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zHealthLivenessResponse.parseAsync(data),
+			url: "/health",
+			...options
+		});
+	}
+	/**
+	* Readiness check - is the service ready to handle requests?
+	* Returns 200 if all dependencies are available, 503 otherwise.
+	*/
+	readiness(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zHealthReadinessResponse.parseAsync(data),
+			url: "/health/ready",
+			...options
+		});
+	}
+	/**
+	* Version check - returns the server version compiled from Cargo.toml.
+	*
+	* Requires a session cookie or a Bearer token, unlike its neighbours in this
+	* scope. `/health` and `/health/ready` answer "is this process up", which a
+	* probe has to be able to ask without credentials; this one answers "which
+	* build is this", which is the first thing worth knowing about a host you
+	* intend to attack.
+	*/
+	version(options) {
+		return (options?.client ?? this.client).get({
+			requestValidator: async (data) => await zod.object({
+				body: zod.never().optional(),
+				path: zod.never().optional(),
+				query: zod.never().optional()
+			}).parseAsync(data),
+			responseValidator: async (data) => await require_zod_gen.zHealthVersionResponse.parseAsync(data),
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}, {
+				in: "cookie",
+				name: "session",
+				type: "apiKey"
+			}],
+			url: "/health/version",
+			...options
+		});
+	}
+};
+var Rustrak = class Rustrak extends HeyApiClient {
+	static __registry = new HeyApiRegistry();
+	constructor(args) {
+		super(args);
+		Rustrak.__registry.set(this, args?.key);
+	}
+	_sourceMaps;
+	get sourceMaps() {
+		return this._sourceMaps ??= new SourceMaps({ client: this.client });
+	}
+	_releases;
+	get releases() {
+		return this._releases ??= new Releases({ client: this.client });
+	}
+	_github;
+	get github() {
+		return this._github ??= new Github({ client: this.client });
+	}
+	_alertChannels;
+	get alertChannels() {
+		return this._alertChannels ??= new AlertChannels({ client: this.client });
+	}
+	_invitations;
+	get invitations() {
+		return this._invitations ??= new Invitations({ client: this.client });
+	}
+	_oauth;
+	get oauth() {
+		return this._oauth ??= new Oauth({ client: this.client });
+	}
+	_projects;
+	get projects() {
+		return this._projects ??= new Projects({ client: this.client });
+	}
+	_agents;
+	get agents() {
+		return this._agents ??= new Agents({ client: this.client });
+	}
+	_alertRules;
+	get alertRules() {
+		return this._alertRules ??= new AlertRules({ client: this.client });
+	}
+	_events;
+	get events() {
+		return this._events ??= new Events({ client: this.client });
+	}
+	_stats;
+	get stats() {
+		return this._stats ??= new Stats({ client: this.client });
+	}
+	_issues;
+	get issues() {
+		return this._issues ??= new Issues({ client: this.client });
+	}
+	_logs;
+	get logs() {
+		return this._logs ??= new Logs({ client: this.client });
+	}
+	_members;
+	get members() {
+		return this._members ??= new Members({ client: this.client });
+	}
+	_monitors;
+	get monitors() {
+		return this._monitors ??= new Monitors({ client: this.client });
+	}
+	_sessions;
+	get sessions() {
+		return this._sessions ??= new Sessions({ client: this.client });
+	}
+	_spans;
+	get spans() {
+		return this._spans ??= new Spans({ client: this.client });
+	}
+	_transactions;
+	get transactions() {
+		return this._transactions ??= new Transactions({ client: this.client });
+	}
+	_schedules;
+	get schedules() {
+		return this._schedules ??= new Schedules({ client: this.client });
+	}
+	_settings;
+	get settings() {
+		return this._settings ??= new Settings({ client: this.client });
+	}
+	_storage;
+	get storage() {
+		return this._storage ??= new Storage({ client: this.client });
+	}
+	_team;
+	get team() {
+		return this._team ??= new Team({ client: this.client });
+	}
+	_telemetry;
+	get telemetry() {
+		return this._telemetry ??= new Telemetry({ client: this.client });
+	}
+	_tokens;
+	get tokens() {
+		return this._tokens ??= new Tokens({ client: this.client });
+	}
+	_auth;
+	get auth() {
+		return this._auth ??= new Auth({ client: this.client });
+	}
+	_health;
+	get health() {
+		return this._health ??= new Health({ client: this.client });
+	}
+};
+//#endregion
+exports.Agents = Agents;
+exports.AlertChannels = AlertChannels;
+exports.AlertRules = AlertRules;
+exports.Auth = Auth;
+exports.Events = Events;
+exports.Github = Github;
+exports.Health = Health;
+exports.Invitations = Invitations;
+exports.Issues = Issues;
+exports.Logs = Logs;
+exports.Members = Members;
+exports.Monitors = Monitors;
+exports.Oauth = Oauth;
+exports.Projects = Projects;
+exports.Releases = Releases;
+exports.Rustrak = Rustrak;
+exports.Schedules = Schedules;
+exports.Sessions = Sessions;
+exports.Settings = Settings;
+exports.SourceMaps = SourceMaps;
+exports.Spans = Spans;
+exports.Stats = Stats;
+exports.Storage = Storage;
+exports.Team = Team;
+exports.Telemetry = Telemetry;
+exports.Tokens = Tokens;
+exports.Transactions = Transactions;
+
+//# sourceMappingURL=sdk.gen.cjs.map