@rustrak/client 0.18.1 → 0.19.1

package/dist/index.js

@@ -1,3232 +0,0 @@
-import { z } from 'zod';
-import ky, { isHTTPError } from 'ky';
-
-// src/resources/agents.ts
-var paginatedResponseSchema = (itemSchema) => z.object({
-  items: z.array(itemSchema),
-  next_cursor: z.string().optional(),
-  has_more: z.boolean()
-});
-var offsetPaginatedResponseSchema = (itemSchema) => z.object({
-  items: z.array(itemSchema),
-  total_count: z.number().int(),
-  page: z.number().int(),
-  per_page: z.number().int(),
-  total_pages: z.number().int()
-});
-z.enum(["asc", "desc"]);
-z.enum([
-  "digest_order",
-  "last_seen",
-  "event_count"
-]);
-var issueFilterSchema = z.enum(["open", "resolved", "muted", "all"]);
-var dateTimeSchema = z.string().datetime();
-var uuidSchema = z.string().uuid();
-var eventIdSchema = z.string().regex(
-  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
-  "Invalid event id"
-);
-z.object({
-  error: z.string(),
-  message: z.string().optional()
-});
-
-// src/schemas/agent.ts
-var agentTimeseriesPointSchema = z.object({
-  bucket: dateTimeSchema,
-  value: z.number()
-});
-var agentDurationPointSchema = z.object({
-  bucket: dateTimeSchema,
-  avg_ms: z.number(),
-  p95_ms: z.number()
-});
-var genAiBreakdownRowSchema = z.object({
-  label: z.string(),
-  value: z.number()
-});
-var agentTraceSummarySchema = z.object({
-  trace_id: z.string(),
-  /** Every distinct agent that ran in this trace, earliest first. */
-  agent_names: z.array(z.string()),
-  duration_ms: z.number().nullable(),
-  total_tokens: z.number(),
-  tool_call_count: z.number().int(),
-  /** `ai_client` spans: how many times a model was actually called. */
-  llm_call_count: z.number().int(),
-  /** AI spans in this trace whose status is set and not `ok`. */
-  error_count: z.number().int(),
-  started_at: dateTimeSchema
-});
-var agentSummarySchema = z.object({
-  agent_runs: z.number().int(),
-  llm_calls: z.number().int(),
-  tool_calls: z.number().int(),
-  error_count: z.number().int(),
-  total_tokens: z.number(),
-  avg_duration_ms: z.number(),
-  p95_duration_ms: z.number()
-});
-var agentModelRowSchema = z.object({
-  model: z.string(),
-  requests: z.number().int(),
-  errors: z.number().int(),
-  avg_ms: z.number(),
-  p95_ms: z.number(),
-  input_tokens: z.number(),
-  cached_input_tokens: z.number(),
-  output_tokens: z.number(),
-  reasoning_output_tokens: z.number(),
-  total_tokens: z.number()
-});
-var agentToolRowSchema = z.object({
-  tool: z.string(),
-  calls: z.number().int(),
-  errors: z.number().int(),
-  avg_ms: z.number(),
-  p95_ms: z.number()
-});
-var providerTypeSchema = z.enum([
-  "webhook",
-  "email",
-  "slack",
-  "custom_webhook"
-]);
-var alertTypeSchema = z.enum(["new_issue", "regression", "unmute"]);
-var alertStatusSchema = z.enum([
-  "pending",
-  "sent",
-  "failed",
-  "skipped"
-]);
-var alertIntegrationSchema = z.object({
-  id: z.number().int(),
-  name: z.string(),
-  provider_type: providerTypeSchema,
-  credentials: z.record(z.string(), z.unknown()),
-  is_enabled: z.boolean(),
-  failure_count: z.number().int(),
-  last_failure_at: dateTimeSchema.nullable(),
-  last_failure_message: z.string().nullable(),
-  last_success_at: dateTimeSchema.nullable(),
-  created_at: dateTimeSchema,
-  updated_at: dateTimeSchema
-});
-var createAlertIntegrationSchema = z.object({
-  name: z.string().min(1),
-  provider_type: providerTypeSchema,
-  credentials: z.record(z.string(), z.unknown()),
-  is_enabled: z.boolean().optional()
-});
-var updateAlertIntegrationSchema = z.object({
-  name: z.string().min(1).optional(),
-  credentials: z.record(z.string(), z.unknown()).optional(),
-  is_enabled: z.boolean().optional()
-});
-var alertRuleChannelInputSchema = z.object({
-  integration_id: z.number().int(),
-  routing_override: z.record(z.string(), z.unknown()).default({})
-});
-var alertRuleConditionsSchema = z.object({
-  /** The quietest level that still fires. The server takes `null` as absent. */
-  min_level: z.enum(["debug", "info", "warning", "error", "fatal"]).nullish(),
-  /** When non-empty, the only environments that fire. */
-  environments: z.array(z.string()).optional(),
-  /** A new issue fires when it reaches this many events, not on its first. */
-  min_events: z.number().int().min(1).nullish()
-});
-var alertRuleSchema = z.object({
-  id: z.number().int(),
-  project_id: z.number().int(),
-  name: z.string(),
-  alert_type: alertTypeSchema,
-  is_enabled: z.boolean(),
-  // A rule stored before the filters existed may hold any object. The server
-  // evaluates one it cannot read as no filters; one bad row must not fail the
-  // whole list either.
-  conditions: alertRuleConditionsSchema.catch({}),
-  cooldown_minutes: z.number().int(),
-  last_triggered_at: dateTimeSchema.nullable(),
-  created_at: dateTimeSchema,
-  updated_at: dateTimeSchema,
-  channels: z.array(alertRuleChannelInputSchema).default([]),
-  integration_ids: z.array(z.number().int())
-});
-var createAlertRuleSchema = z.object({
-  name: z.string().min(1),
-  alert_type: alertTypeSchema,
-  channels: z.array(alertRuleChannelInputSchema).default([]),
-  is_enabled: z.boolean().optional(),
-  conditions: alertRuleConditionsSchema.optional(),
-  cooldown_minutes: z.number().int().min(0).optional()
-});
-var updateAlertRuleSchema = z.object({
-  name: z.string().min(1).optional(),
-  is_enabled: z.boolean().optional(),
-  conditions: alertRuleConditionsSchema.optional(),
-  cooldown_minutes: z.number().int().min(0).optional(),
-  channels: z.array(alertRuleChannelInputSchema).optional()
-});
-var alertHistorySchema = z.object({
-  id: z.number().int(),
-  alert_rule_id: z.number().int().nullable(),
-  integration_id: z.number().int().nullable(),
-  issue_id: z.string().uuid().nullable(),
-  project_id: z.number().int().nullable(),
-  alert_type: z.string(),
-  channel_type: z.string(),
-  channel_name: z.string(),
-  status: alertStatusSchema,
-  attempt_count: z.number().int(),
-  next_retry_at: dateTimeSchema.nullable(),
-  error_message: z.string().nullable(),
-  http_status_code: z.number().int().nullable(),
-  idempotency_key: z.string(),
-  created_at: dateTimeSchema,
-  sent_at: dateTimeSchema.nullable()
-});
-var testChannelResponseSchema = z.object({
-  success: z.boolean(),
-  message: z.string(),
-  /**
-   * What the endpoint answered, when it answered anything.
-   *
-   * Delivery is judged by the HTTP status and the body is not interpreted, so
-   * the body is handed back instead: a group bot that refuses a message still
-   * answers 200 and explains itself here.
-   */
-  response_body: z.string().nullish()
-});
-var previewTemplateResponseSchema = z.object({
-  ok: z.boolean(),
-  rendered: z.string().nullish(),
-  error: z.string().nullish()
-});
-var testIntegrationBodySchema = z.object({
-  routing_override: z.record(z.string(), z.unknown()).optional()
-});
-var eventSchema = z.object({
-  id: uuidSchema,
-  event_id: eventIdSchema,
-  issue_id: uuidSchema.nullable(),
-  title: z.string(),
-  timestamp: dateTimeSchema,
-  level: z.string(),
-  platform: z.string(),
-  release: z.string(),
-  environment: z.string(),
-  event_type: z.string()
-});
-var eventDetailSchema = z.object({
-  id: uuidSchema,
-  event_id: eventIdSchema,
-  issue_id: uuidSchema.nullable(),
-  title: z.string(),
-  timestamp: dateTimeSchema,
-  ingested_at: dateTimeSchema,
-  level: z.string(),
-  platform: z.string(),
-  release: z.string(),
-  environment: z.string(),
-  server_name: z.string(),
-  sdk_name: z.string(),
-  sdk_version: z.string(),
-  event_type: z.string(),
-  data: z.record(z.string(), z.any())
-  // Full Sentry event JSON
-});
-var gitHubAppSchema = z.object({
-  app_id: z.number().int(),
-  slug: z.string(),
-  html_url: z.string(),
-  owner_login: z.string(),
-  install_url: z.string(),
-  last_webhook_at: dateTimeSchema.nullable(),
-  created_at: dateTimeSchema
-});
-var gitHubInstallationSchema = z.object({
-  id: z.number().int(),
-  account_login: z.string(),
-  account_type: z.string(),
-  suspended: z.boolean(),
-  created_at: dateTimeSchema
-});
-var gitHubStatusSchema = z.object({
-  app: gitHubAppSchema.nullable(),
-  installations: z.array(gitHubInstallationSchema),
-  webhook_url: z.string()
-});
-var gitHubManifestSchema = z.object({
-  action_url: z.string(),
-  manifest: z.string()
-});
-var gitHubRepositorySchema = z.object({
-  installation_id: z.number().int(),
-  full_name: z.string(),
-  default_branch: z.string(),
-  private: z.boolean(),
-  html_url: z.string()
-});
-var codeMappingSchema = z.object({
-  stack_root: z.string(),
-  source_root: z.string()
-});
-var projectRepositorySchema = z.object({
-  project_id: z.number().int(),
-  installation_id: z.number().int(),
-  repo_full_name: z.string(),
-  default_branch: z.string(),
-  html_url: z.string(),
-  code_mappings: z.array(codeMappingSchema),
-  /** Open a GitHub issue for new issues that pass `auto_create_conditions`. */
-  auto_create_issues: z.boolean(),
-  auto_create_conditions: alertRuleConditionsSchema,
-  codeowners_rules: z.number().int().nullable(),
-  codeowners_synced_at: dateTimeSchema.nullable()
-});
-var updateProjectRepositorySchema = z.object({
-  installation_id: z.number().int(),
-  repo_full_name: z.string().min(1),
-  code_mappings: z.array(codeMappingSchema).optional(),
-  auto_create_issues: z.boolean().optional(),
-  auto_create_conditions: alertRuleConditionsSchema.optional()
-});
-var issueLinkSchema = z.object({
-  id: z.number().int(),
-  issue_id: z.string(),
-  repo_full_name: z.string(),
-  number: z.number().int(),
-  title: z.string(),
-  url: z.string(),
-  state: z.string(),
-  created_at: dateTimeSchema
-});
-var repoCommitSchema = z.object({
-  repo_full_name: z.string(),
-  sha: z.string(),
-  message: z.string(),
-  author_name: z.string(),
-  author_login: z.string().nullable(),
-  url: z.string(),
-  committed_at: dateTimeSchema
-});
-var issueGitHubSchema = z.object({
-  links: z.array(issueLinkSchema),
-  suspect_commits: z.array(repoCommitSchema),
-  owners: z.array(z.string())
-});
-var gitHubLoginSchema = z.object({
-  login: z.string().nullable()
-});
-var globalRoleSchema = z.enum(["admin", "member"]);
-var teamMemberSchema = z.object({
-  id: z.number().int(),
-  email: z.string().email(),
-  role: globalRoleSchema,
-  is_active: z.boolean(),
-  /** True for the first-registered account, which cannot be demoted or deleted. */
-  is_primary: z.boolean().optional(),
-  created_at: dateTimeSchema,
-  last_login: dateTimeSchema.nullable().optional()
-});
-var updateUserRoleSchema = z.object({
-  role: globalRoleSchema
-});
-
-// src/schemas/invitation.ts
-var invitationStatusSchema = z.string();
-var invitationSchema = z.object({
-  token: z.string(),
-  email: z.string().email(),
-  role: globalRoleSchema,
-  status: invitationStatusSchema,
-  expires_at: dateTimeSchema,
-  created_at: dateTimeSchema
-});
-var invitationInfoSchema = z.object({
-  email: z.string().email(),
-  role: globalRoleSchema,
-  status: invitationStatusSchema,
-  expires_at: dateTimeSchema
-});
-var createInvitationSchema = z.object({
-  email: z.string().email(),
-  role: globalRoleSchema
-});
-var acceptInvitationSchema = z.object({
-  token: z.string().min(1),
-  password: z.string().min(1)
-});
-var issueStatusSchema = z.enum(["unresolved", "resolved", "ignored"]);
-var issuePrioritySchema = z.enum(["low", "medium", "high"]);
-var issueSchema = z.object({
-  id: uuidSchema,
-  project_id: z.number().int(),
-  short_id: z.string(),
-  title: z.string(),
-  value: z.string(),
-  culprit: z.string(),
-  logger: z.string(),
-  first_seen: dateTimeSchema,
-  last_seen: dateTimeSchema,
-  event_count: z.number().int(),
-  level: z.string().nullable(),
-  platform: z.string().nullable(),
-  // Status model (#165)
-  status: issueStatusSchema,
-  substatus: z.string().nullable(),
-  priority: issuePrioritySchema.nullable(),
-  assigned_to: z.number().int().nullable(),
-  assignee_type: z.string().nullable(),
-  issue_type: z.string(),
-  issue_category: z.string(),
-  first_release: z.string(),
-  last_release: z.string(),
-  status_details: z.record(z.string(), z.unknown()),
-  // Aggregate enrichment — only the single-issue GET populates this; the list
-  // and PATCH endpoints return the lean response, so default to 0 when absent.
-  user_report_count: z.number().int().optional().default(0),
-  // Per-user fields — only present when the request carries a user session.
-  is_bookmarked: z.boolean().optional(),
-  is_subscribed: z.boolean().optional(),
-  has_seen: z.boolean().optional(),
-  // Bulk list stats — only the list endpoint populates these (computed once
-  // per page); the single-issue GET and PATCH responses omit them.
-  user_count: z.number().int().optional(),
-  trend: z.array(z.number().int()).optional(),
-  // Deprecated, derived from `status`; kept for backward compatibility.
-  is_resolved: z.boolean(),
-  is_muted: z.boolean()
-});
-var updateIssueStateSchema = z.object({
-  status: z.union([issueStatusSchema, z.literal("resolvedInNextRelease")]).optional(),
-  substatus: z.string().optional(),
-  priority: issuePrioritySchema.optional(),
-  assigned_to: z.number().int().nullable().optional(),
-  assignee_type: z.string().nullable().optional(),
-  is_resolved: z.boolean().optional(),
-  is_muted: z.boolean().optional()
-});
-var issueHashSchema = z.object({
-  id: z.number().int(),
-  project_id: z.number().int(),
-  issue_id: uuidSchema,
-  grouping_key: z.string(),
-  grouping_key_hash: z.string(),
-  created_at: dateTimeSchema
-});
-var tagValueCountSchema = z.object({
-  value: z.string(),
-  count: z.number().int()
-});
-var issueTagValueSchema = z.object({
-  key: z.string(),
-  name: z.string(),
-  value: z.string(),
-  count: z.number().int(),
-  first_seen: dateTimeSchema,
-  last_seen: dateTimeSchema
-});
-var tagSummarySchema = z.object({
-  key: z.string(),
-  total_values: z.number().int(),
-  top_values: z.array(tagValueCountSchema)
-});
-var issueAggregatesSchema = z.object({
-  user_count: z.number().int(),
-  tags: z.array(tagSummarySchema)
-});
-z.enum(["24h", "30d"]);
-var issueStatsSchema = z.object({
-  data: z.array(z.tuple([z.number(), z.number()]))
-});
-var activityEntrySchema = z.object({
-  id: uuidSchema,
-  issue_id: uuidSchema,
-  user_id: z.number().int().nullable(),
-  type: z.string(),
-  data: z.string(),
-  created_at: dateTimeSchema
-});
-var userReportSchema = z.object({
-  id: uuidSchema,
-  project_id: z.number().int(),
-  issue_id: uuidSchema.nullable(),
-  event_id: uuidSchema.nullable(),
-  name: z.string(),
-  // Server stores '' for anonymous reports (column DEFAULT '' / unwrap_or_default),
-  // matching real Sentry's own save_userreport(report.get("email", "")) — accept it.
-  email: z.union([z.email(), z.literal("")]),
-  comments: z.string(),
-  created_at: dateTimeSchema
-});
-var createCommentSchema = z.object({
-  text: z.string()
-});
-var createUserReportSchema = z.object({
-  name: z.string().optional(),
-  email: z.email().optional(),
-  comments: z.string().optional(),
-  event_id: uuidSchema.optional()
-});
-var bulkUpdateIssuesSchema = z.object({
-  ids: z.array(uuidSchema),
-  status: z.union([issueStatusSchema, z.literal("resolvedInNextRelease")]).optional(),
-  priority: issuePrioritySchema.optional()
-});
-var bulkDeleteIssuesSchema = z.union([
-  z.strictObject({ ids: z.array(uuidSchema) }),
-  z.strictObject({ filter: issueFilterSchema })
-]);
-var logSchema = z.object({
-  id: uuidSchema,
-  trace_id: z.string().nullable(),
-  span_id: z.string().nullable(),
-  level: z.string(),
-  /** OTel severity number (1=trace … 21=fatal). Null for unknown levels. */
-  severity_number: z.number().int().nullable(),
-  body: z.string(),
-  attributes: z.record(z.string(), z.any()),
-  timestamp: dateTimeSchema,
-  ingested_at: dateTimeSchema
-});
-var projectRoleSchema = z.enum(["viewer", "editor", "admin"]);
-var projectMemberSchema = z.object({
-  user_id: z.number().int(),
-  email: z.string().email(),
-  role: projectRoleSchema,
-  created_at: dateTimeSchema
-});
-var upsertProjectMemberSchema = z.object({
-  user_id: z.number().int(),
-  role: projectRoleSchema
-});
-var intervalUnitSchema = z.enum([
-  "minute",
-  "hour",
-  "day",
-  "week",
-  "month",
-  "year"
-]);
-var scheduleSchema = z.discriminatedUnion("type", [
-  z.object({ type: z.literal("crontab"), value: z.string() }),
-  z.object({
-    type: z.literal("interval"),
-    value: z.number().int().min(1),
-    unit: intervalUnitSchema
-  })
-]);
-var previewScheduleSchema = z.object({
-  schedule: scheduleSchema,
-  /** IANA zone the schedule is read in. Defaults to UTC. */
-  timezone: z.string().optional()
-});
-var schedulePreviewSchema = z.object({
-  next_runs: z.array(dateTimeSchema)
-});
-
-// src/schemas/monitor.ts
-var monitorConfigSchema = z.object({
-  schedule: scheduleSchema,
-  checkin_margin: z.number().int(),
-  max_runtime: z.number().int(),
-  timezone: z.string(),
-  failure_issue_threshold: z.number().int(),
-  recovery_threshold: z.number().int()
-});
-var monitorConfigInputSchema = z.object({
-  schedule: scheduleSchema.optional(),
-  checkin_margin: z.number().int().min(1).optional(),
-  max_runtime: z.number().int().min(1).optional(),
-  timezone: z.string().optional(),
-  failure_issue_threshold: z.number().int().min(1).max(720).optional(),
-  recovery_threshold: z.number().int().min(1).max(720).optional()
-});
-var checkInStatusSchema = z.enum([
-  "ok",
-  "error",
-  "in_progress",
-  "missed",
-  "timeout",
-  "unknown"
-]);
-var monitorEnvironmentStatusSchema = z.enum(["active", "ok", "error"]);
-var checkInSchema = z.object({
-  id: uuidSchema,
-  environment: z.string(),
-  status: checkInStatusSchema,
-  duration_ms: z.number().int().nullable(),
-  date_added: dateTimeSchema,
-  date_updated: dateTimeSchema,
-  expected_time: dateTimeSchema.nullable()
-});
-var monitorEnvironmentSchema = z.object({
-  id: uuidSchema,
-  environment: z.string(),
-  status: monitorEnvironmentStatusSchema,
-  next_checkin: dateTimeSchema.nullable(),
-  next_checkin_latest: dateTimeSchema.nullable(),
-  last_checkin: dateTimeSchema.nullable(),
-  /** Newest first. */
-  recent_checkins: z.array(checkInSchema)
-});
-var monitorSchema = z.object({
-  id: uuidSchema,
-  slug: z.string(),
-  name: z.string(),
-  config: monitorConfigSchema,
-  is_muted: z.boolean(),
-  created_at: dateTimeSchema,
-  environments: z.array(monitorEnvironmentSchema)
-});
-var createMonitorSchema = z.object({
-  name: z.string().trim().min(1).max(128),
-  /** Derived from `name` when left out. */
-  slug: z.string().min(1).max(50).optional(),
-  config: monitorConfigInputSchema
-});
-var updateMonitorSchema = z.object({
-  name: z.string().trim().min(1).max(128).optional(),
-  config: monitorConfigInputSchema.optional(),
-  is_muted: z.boolean().optional()
-});
-var metricDeltaSchema = z.object({
-  current: z.number().int(),
-  /**
-   * The same window immediately before this one. Null only for all-time
-   * requests, where a `0` would render as a misleading "+100%".
-   */
-  previous: z.number().int().nullable()
-});
-var projectListStatsSchema = z.object({
-  /**
-   * Distinct issues active in each bucket, oldest first. A shape, not a
-   * total: an issue firing all day appears in every bucket it touched.
-   */
-  trend: z.array(z.number().int()),
-  events: metricDeltaSchema,
-  /** Issues first seen in the window. Drives the "getting worse" signal. */
-  new_issues: metricDeltaSchema,
-  /** Unresolved issues right now, independent of the window. */
-  open_issues: z.number().int(),
-  /** The subset of `open_issues` at `fatal` level. */
-  fatal_issues: z.number().int()
-});
-var projectSchema = z.object({
-  id: z.number().int(),
-  name: z.string(),
-  slug: z.string(),
-  sentry_key: uuidSchema,
-  dsn: z.string(),
-  stored_event_count: z.number().int(),
-  digested_event_count: z.number().int(),
-  /** Accepted events the quota dropped instead of storing. */
-  rate_limited_event_count: z.number().int(),
-  /**
-   * The project's own limits, or null where it follows the server's. They can
-   * only tighten `MAX_EVENTS_PER_PROJECT_*`, never raise it.
-   */
-  rate_limit_per_minute: z.number().int().nullable(),
-  rate_limit_per_hour: z.number().int().nullable(),
-  created_at: dateTimeSchema,
-  updated_at: dateTimeSchema,
-  platform: z.string().nullable(),
-  stats: projectListStatsSchema.optional()
-});
-var createProjectSchema = z.object({
-  name: z.string().min(1),
-  /**
-   * Slugified server-side. Supplying it means the user chose it, so a taken
-   * slug is a 409. Omitting it derives one from the name and silently
-   * de-duplicates, since nobody chose that value.
-   */
-  slug: z.string().min(1).optional(),
-  /**
-   * Validated server-side against SELECTABLE_PLATFORMS. Omitting it leaves the
-   * project eligible for platform auto-detection from its first event.
-   */
-  platform: z.string().min(1).optional()
-});
-var updateProjectSchema = z.object({
-  name: z.string().min(1).optional(),
-  platform: z.string().min(1).optional(),
-  /**
-   * Slugified server-side. Unlike on create, a taken slug is a 409 rather than
-   * being silently de-duplicated.
-   */
-  slug: z.string().min(1).optional(),
-  /** A number sets the project's own limit; null removes it. */
-  rate_limit_per_minute: z.number().int().min(1).nullable().optional(),
-  rate_limit_per_hour: z.number().int().min(1).nullable().optional()
-});
-var rateLimitsSchema = z.object({
-  project_per_minute: z.number().int(),
-  project_per_hour: z.number().int()
-});
-var releaseHealthRowSchema = z.object({
-  release: z.string(),
-  environment: z.string(),
-  total: z.number().int(),
-  errored: z.number().int(),
-  crashed: z.number().int(),
-  abnormal: z.number().int(),
-  healthy: z.number().int(),
-  crash_free_sessions_rate: z.number().nullable(),
-  crash_free_users_rate: z.number().nullable()
-});
-var sessionSummarySchema = z.object({
-  total: z.number().int(),
-  errored: z.number().int(),
-  crashed: z.number().int(),
-  abnormal: z.number().int(),
-  crash_free_sessions_rate: z.number().nullable(),
-  crash_free_users_rate: z.number().nullable(),
-  active_releases: z.number().int()
-});
-var sessionTimeseriesPointSchema = z.object({
-  bucket: dateTimeSchema,
-  total: z.number().int(),
-  crashed: z.number().int(),
-  crash_free_sessions_rate: z.number().nullable()
-});
-var sessionTimeseriesSchema = z.array(sessionTimeseriesPointSchema);
-var chunkUploadCapabilitySchema = z.object({
-  url: z.string(),
-  chunkSize: z.number().int(),
-  chunksPerRequest: z.number().int(),
-  maxRequestSize: z.number().int(),
-  hashAlgorithm: z.string(),
-  accept: z.array(z.string()),
-  concurrency: z.number().int().optional()
-});
-var assembleInputSchema = z.object({
-  checksum: z.string().min(1),
-  chunks: z.array(z.string().min(1)),
-  projects: z.array(z.string().min(1)).min(1)
-});
-var assembleResponseSchema = z.object({
-  state: z.string(),
-  missingChunks: z.array(z.string()),
-  detail: z.string().optional()
-});
-var sourceMapFileSchema = z.object({
-  debugId: z.string(),
-  fileType: z.string(),
-  size: z.number().int(),
-  timesUsed: z.number().int(),
-  dateUploaded: z.string()
-});
-var listSourceMapsResponseSchema = z.object({
-  data: z.array(sourceMapFileSchema)
-});
-var eventTimeseriesPointSchema = z.object({
-  bucket: dateTimeSchema,
-  total: z.number().int(),
-  fatal: z.number().int(),
-  error: z.number().int(),
-  warning: z.number().int(),
-  info: z.number().int()
-});
-var eventTimeseriesSchema = z.array(eventTimeseriesPointSchema);
-var metricDeltaSchema2 = z.object({
-  current: z.number().int(),
-  previous: z.number().int().nullable()
-});
-var projectStatsSummarySchema = z.object({
-  /** Resolved window in hours, or `null` for all time. */
-  period_hours: z.number().int().nullable(),
-  events: metricDeltaSchema2,
-  new_issues: metricDeltaSchema2,
-  /** Currently unresolved issues, independent of the window. */
-  open_issues: z.number().int()
-});
-var sourceMapStorageSchema = z.object({
-  chunk_bytes: z.number(),
-  source_file_bytes: z.number(),
-  total_bytes: z.number(),
-  file_count: z.number()
-});
-var storageSummarySchema = z.object({
-  total_db_size_bytes: z.number(),
-  events_count: z.number(),
-  transactions_count: z.number(),
-  spans_count: z.number(),
-  logs_count: z.number(),
-  source_maps: sourceMapStorageSchema
-});
-var projectStorageSchema = z.object({
-  project_id: z.number(),
-  project_name: z.string(),
-  events_count: z.number(),
-  transactions_count: z.number(),
-  spans_count: z.number(),
-  logs_count: z.number(),
-  source_maps_count: z.number(),
-  /** `events_bytes + transactions_bytes + logs_bytes`. */
-  estimated_bytes: z.number(),
-  events_bytes: z.number(),
-  /** Transactions with their spans. */
-  transactions_bytes: z.number(),
-  logs_bytes: z.number()
-});
-var cleanupCountsSchema = z.object({
-  events: z.number(),
-  transactions: z.number(),
-  spans: z.number(),
-  logs: z.number(),
-  issues_removed: z.number(),
-  /** Unused source maps deleted; only a retention cleanup removes them. */
-  source_maps: z.number().default(0)
-});
-var cleanupStatusSchema = z.object({
-  state: z.enum(["idle", "running", "completed", "failed"]),
-  removed: cleanupCountsSchema,
-  started_at: z.string().nullable(),
-  finished_at: z.string().nullable(),
-  error: z.string().nullable()
-});
-var sourceMapGcResultSchema = z.object({
-  files_removed: z.number(),
-  bytes_freed: z.number()
-});
-var kindAgeSchema = z.object({
-  counts: z.array(z.number()),
-  oldest: dateTimeSchema.nullable()
-});
-var storageAgeSchema = z.object({
-  bucket_days: z.array(z.number()),
-  projects: z.array(
-    z.object({
-      project_id: z.number(),
-      events: kindAgeSchema,
-      transactions: kindAgeSchema,
-      logs: kindAgeSchema
-    })
-  )
-});
-var retentionDaysSchema = z.number().int().min(1).max(36500).nullable();
-var retentionWindowsSchema = z.object({
-  events_days: retentionDaysSchema,
-  /** Transactions with their spans. */
-  transactions_days: retentionDaysSchema,
-  logs_days: retentionDaysSchema
-});
-var projectRetentionSchema = retentionWindowsSchema.extend({
-  project_id: z.number().int()
-});
-var retentionSettingsSchema = z.object({
-  defaults: retentionWindowsSchema,
-  overrides: z.array(projectRetentionSchema),
-  frequency: z.enum(["daily", "weekly"]),
-  /** Hour of the day, UTC. */
-  hour: z.number().int().min(0).max(23),
-  /** Day of a weekly cleanup, 0 = Sunday. */
-  weekday: z.number().int().min(0).max(6)
-});
-var retentionRunSchema = z.object({
-  started_at: dateTimeSchema,
-  finished_at: dateTimeSchema.nullable(),
-  status: z.enum(["running", "ok", "error"]),
-  removed: cleanupCountsSchema.nullable(),
-  error: z.string().nullable()
-});
-var retentionSchema = z.object({
-  settings: retentionSettingsSchema,
-  /** Null while everything is kept forever, and for up to a minute after the settings change. */
-  next_run_at: dateTimeSchema.nullable(),
-  last_run: retentionRunSchema.nullable()
-});
-var cleanupOptionsSchema = z.object({
-  older_than_days: z.number().int().min(1),
-  project_id: z.number().int().optional(),
-  include_events: z.boolean().optional(),
-  include_transactions: z.boolean().optional(),
-  include_logs: z.boolean().optional()
-});
-var authTokenSchema = z.object({
-  id: z.number().int(),
-  token_prefix: z.string(),
-  description: z.string().nullable(),
-  created_at: dateTimeSchema,
-  last_used_at: dateTimeSchema.nullable()
-});
-var authTokenCreatedSchema = z.object({
-  id: z.number().int(),
-  token: z.string(),
-  description: z.string().nullable(),
-  created_at: dateTimeSchema
-});
-var createAuthTokenSchema = z.object({
-  description: z.string().optional()
-});
-var transactionSchema = z.object({
-  id: uuidSchema,
-  event_id: eventIdSchema,
-  transaction_name: z.string(),
-  timestamp: dateTimeSchema,
-  start_timestamp: dateTimeSchema.nullable(),
-  duration_ms: z.number().nullable(),
-  platform: z.string(),
-  environment: z.string(),
-  release: z.string(),
-  ingested_at: dateTimeSchema
-});
-var transactionDetailSchema = z.object({
-  id: uuidSchema,
-  event_id: eventIdSchema,
-  transaction_name: z.string(),
-  timestamp: dateTimeSchema,
-  start_timestamp: dateTimeSchema.nullable(),
-  duration_ms: z.number().nullable(),
-  platform: z.string(),
-  environment: z.string(),
-  release: z.string(),
-  ingested_at: dateTimeSchema,
-  data: z.record(z.string(), z.any())
-  // Full Sentry transaction payload
-});
-var spanSchema = z.object({
-  id: uuidSchema,
-  /** Parent transaction, if this span was extracted from one. `null` for a standalone span. */
-  transaction_id: uuidSchema.nullable(),
-  span_id: z.string().nullable(),
-  trace_id: z.string().nullable(),
-  parent_span_id: z.string().nullable(),
-  op: z.string().nullable(),
-  description: z.string().nullable(),
-  status: z.string().nullable(),
-  start_timestamp: dateTimeSchema.nullable(),
-  timestamp: dateTimeSchema.nullable(),
-  duration_ms: z.number().nullable(),
-  exclusive_time_ms: z.number().nullable(),
-  is_segment: z.boolean(),
-  segment_id: z.string().nullable(),
-  /** Reported by the span itself, or stamped from its parent transaction. Null only for rows ingested before that stamping existed. */
-  platform: z.string().nullable(),
-  release: z.string().nullable(),
-  environment: z.string().nullable(),
-  /** gen_ai.* denormalized fields — all null unless recognized as an AI span. */
-  gen_ai_operation_type: z.string().nullable(),
-  gen_ai_agent_name: z.string().nullable(),
-  gen_ai_request_model: z.string().nullable(),
-  gen_ai_response_model: z.string().nullable(),
-  gen_ai_tool_name: z.string().nullable(),
-  gen_ai_conversation_id: z.string().nullable(),
-  gen_ai_usage_input_tokens: z.number().nullable(),
-  gen_ai_usage_output_tokens: z.number().nullable(),
-  gen_ai_usage_total_tokens: z.number().nullable()
-});
-var spanDetailSchema = spanSchema.extend({
-  attributes: z.record(z.string(), z.any()),
-  /** Always absent for a Spans Protocol v2 span: v2 has no tags concept. */
-  tags: z.record(z.string(), z.any()).nullish()
-});
-var transactionStatsSchema = z.object({
-  transaction_name: z.string(),
-  op: z.string().nullable(),
-  count: z.number().int(),
-  p50_ms: z.number(),
-  p95_ms: z.number(),
-  p99_ms: z.number(),
-  failure_rate: z.number()
-});
-var userSchema = z.object({
-  id: z.number().int().positive(),
-  email: z.string().email(),
-  role: globalRoleSchema,
-  is_admin: z.boolean(),
-  /**
-   * The dashboard language this user chose.
-   *
-   * `null` means they never chose one, which a consumer should treat as
-   * "infer it" rather than as English. Optional as well as nullable so a
-   * client stays compatible with a server predating the column.
-   */
-  language: z.string().nullable().optional(),
-  /** The IANA timezone this user chose, `null` when they never chose one. */
-  timezone: z.string().nullable().optional()
-});
-var updatePreferencesRequestSchema = z.object({
-  language: z.string().nullable().optional(),
-  timezone: z.string().nullable().optional()
-});
-var authResponseSchema = z.object({
-  user: userSchema
-});
-z.object({
-  user: userSchema,
-  cookies: z.array(z.string())
-});
-var loginRequestSchema = z.object({
-  email: z.string().email(),
-  password: z.string().min(1)
-});
-var registerRequestSchema = z.object({
-  email: z.string().email(),
-  password: z.string().min(1)
-});
-var ssoConfigSchema = z.object({
-  enabled: z.boolean(),
-  provider_name: z.string().nullable()
-});
-var ssoStartSchema = z.object({
-  authorization_url: z.string().url()
-});
-var ssoLinkSchema = z.object({
-  email: z.string(),
-  provider_name: z.string()
-});
-var confirmSsoLinkRequestSchema = z.object({
-  password: z.string().min(1)
-});
-var changePasswordRequestSchema = z.object({
-  current_password: z.string().min(1),
-  new_password: z.string().min(1)
-});
-
-// src/errors.ts
-var FIELD_ERROR_CODES = [
-  "required",
-  "invalid",
-  "already_exists",
-  "too_short",
-  "too_long",
-  "custom"
-];
-var SERVER_ERROR_MESSAGE = "The server failed to handle the request.";
-var NETWORK_ERROR_MESSAGE = "The request could not reach the server.";
-var TIMEOUT_ERROR_MESSAGE = "The request timed out.";
-function isRetryable(error) {
-  return error.kind === "network" || error.kind === "server_error" || error.kind === "rate_limited";
-}
-
-// src/result.ts
-function Ok(data) {
-  return { success: true, data };
-}
-function Err(error) {
-  return { success: false, error };
-}
-function unwrap(result) {
-  if (result.success) {
-    return result.data;
-  }
-  throw new Error(
-    `unwrap() called on a failed Result: ${describe(result.error)}`
-  );
-}
-function unwrapOr(result, fallback) {
-  return result.success ? result.data : fallback;
-}
-function mapResult(result, fn) {
-  return result.success ? Ok(fn(result.data)) : result;
-}
-function describe(error) {
-  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
-    return error.message;
-  }
-  return String(error);
-}
-var RustrakTransportFailure = class extends Error {
-  rustrakError;
-  constructor(error) {
-    super(error.message);
-    this.name = "RustrakTransportFailure";
-    this.rustrakError = error;
-  }
-};
-function isTransportFailure(value) {
-  return value instanceof RustrakTransportFailure;
-}
-function readErrorMessage(error, status) {
-  const fallback = `HTTP ${status} error`;
-  const body = error.data;
-  if (body && typeof body === "object") {
-    const nested = typeof body.error === "object" ? body.error?.message : body.error;
-    return nested || body.message || fallback;
-  }
-  return fallback;
-}
-var KNOWN_FIELD_ERROR_CODES = new Set(FIELD_ERROR_CODES);
-function isFieldErrorCode(value) {
-  return typeof value === "string" && KNOWN_FIELD_ERROR_CODES.has(value);
-}
-var warnedFieldErrorCodes = /* @__PURE__ */ new Set();
-function warnUnknownFieldErrorCode(code, field) {
-  if (warnedFieldErrorCodes.has(code)) return;
-  warnedFieldErrorCodes.add(code);
-  console.warn(
-    `[@rustrak/client] Dropped a field error with an unrecognised code "${code}" (field "${field}"). This client build does not know that code, so the affected inputs degrade to a form-level error. The server is most likely newer than @rustrak/client; upgrade the client to match the server version.`
-  );
-}
-function readIncidentId(error) {
-  const body = error.data;
-  const raw = body && typeof body === "object" ? body.error?.incident_id : void 0;
-  return typeof raw === "string" && raw.length > 0 ? raw : void 0;
-}
-function readFieldErrors(error) {
-  const body = error.data;
-  const raw = body && typeof body === "object" ? body.error?.fields : void 0;
-  if (!Array.isArray(raw)) {
-    return void 0;
-  }
-  const fields = [];
-  for (const entry of raw) {
-    if (typeof entry !== "object" || entry === null) continue;
-    const { field, code, message } = entry;
-    if (typeof field !== "string") continue;
-    if (!isFieldErrorCode(code)) {
-      if (typeof code === "string") warnUnknownFieldErrorCode(code, field);
-      continue;
-    }
-    fields.push(
-      code === "custom" && typeof message === "string" ? { field, code, message } : { field, code }
-    );
-  }
-  return fields.length > 0 ? fields : void 0;
-}
-function readRetryAfter(response) {
-  const header = response.headers.get("Retry-After")?.trim();
-  if (!header) {
-    return void 0;
-  }
-  if (/^\d+$/.test(header)) {
-    return Number.parseInt(header, 10);
-  }
-  if (/^[+-]\d+$/.test(header)) {
-    return void 0;
-  }
-  const date = Date.parse(header);
-  if (Number.isNaN(date)) {
-    return void 0;
-  }
-  return Math.max(0, Math.ceil((date - Date.now()) / 1e3));
-}
-function annotate(base, fields) {
-  return fields === void 0 ? base : { ...base, fields };
-}
-function transformHttpError(error) {
-  const { response } = error;
-  const status = response.status;
-  if (status >= 500) {
-    const base = {
-      kind: "server_error",
-      status,
-      message: SERVER_ERROR_MESSAGE
-    };
-    const incidentId = readIncidentId(error);
-    return incidentId === void 0 ? base : { ...base, incidentId };
-  }
-  const message = readErrorMessage(error, status);
-  const fields = readFieldErrors(error);
-  switch (status) {
-    case 400:
-      return annotate({ kind: "validation", status, message }, fields);
-    case 401:
-      return annotate({ kind: "unauthenticated", status, message }, fields);
-    case 403:
-      return annotate({ kind: "forbidden", status, message }, fields);
-    case 404:
-      return annotate({ kind: "not_found", status, message }, fields);
-    case 409:
-      return annotate({ kind: "conflict", status, message }, fields);
-    case 410:
-      return annotate({ kind: "gone", status, message }, fields);
-    case 413:
-      return annotate({ kind: "payload_too_large", status, message }, fields);
-    case 429: {
-      const retryAfter = readRetryAfter(response);
-      return annotate(
-        retryAfter === void 0 ? { kind: "rate_limited", status, message } : { kind: "rate_limited", status, message, retryAfter },
-        fields
-      );
-    }
-    default:
-      return annotate({ kind: "client_error", status, message }, fields);
-  }
-}
-function createKyInstance(config) {
-  const headers = {
-    // `Accept` is set here rather than relied on from ky. The `.json()`
-    // shortcut sets it before the request is issued, and `BaseResource` no
-    // longer uses that shortcut: it awaits the `Response` and parses the body
-    // itself, so without this every one of the 86 methods would send `*/*` and
-    // any content-negotiating hop could answer with HTML.
-    Accept: "application/json",
-    "Content-Type": "application/json",
-    ...config.headers
-  };
-  if (config.token) {
-    headers.Authorization = `Bearer ${config.token}`;
-  }
-  return ky.create({
-    prefix: config.baseUrl,
-    timeout: config.timeout ?? 3e4,
-    credentials: "include",
-    retry: {
-      limit: config.maxRetries ?? 2,
-      statusCodes: [408, 500, 502, 503, 504],
-      methods: ["get", "post", "put", "patch", "delete"]
-    },
-    headers,
-    hooks: {
-      beforeError: [
-        ({ error }) => {
-          if (error.name === "TimeoutError") {
-            throw new RustrakTransportFailure({
-              kind: "network",
-              message: TIMEOUT_ERROR_MESSAGE,
-              reason: "timeout"
-            });
-          }
-          if (isHTTPError(error)) {
-            throw new RustrakTransportFailure(transformHttpError(error));
-          }
-          throw new RustrakTransportFailure({
-            kind: "network",
-            message: NETWORK_ERROR_MESSAGE,
-            reason: "unreachable"
-          });
-        }
-      ]
-    }
-  });
-}
-
-// src/resources/base.ts
-var TRANSPORT_TYPE_ERROR = /terminated|aborted|socket|network|closed|reset|fetch failed/i;
-function isProgrammingError(error) {
-  if (!(error instanceof Error)) {
-    return true;
-  }
-  if (error instanceof ReferenceError || error instanceof RangeError) {
-    return true;
-  }
-  if (error instanceof TypeError) {
-    return error.cause === void 0 && !TRANSPORT_TYPE_ERROR.test(error.message);
-  }
-  return false;
-}
-function classifyBodyFailure(error) {
-  if (error instanceof SyntaxError) {
-    return {
-      kind: "invalid_response",
-      message: "The server returned a body that is not valid JSON."
-    };
-  }
-  if (isProgrammingError(error)) {
-    return "rethrow";
-  }
-  return {
-    kind: "network",
-    message: NETWORK_ERROR_MESSAGE,
-    reason: error instanceof Error && error.name === "TimeoutError" ? "timeout" : "unreachable"
-  };
-}
-function discardBody(response) {
-  try {
-    void response.body?.cancel().catch(() => {
-    });
-  } catch {
-  }
-}
-var BaseResource = class {
-  http;
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Validate an API response against its Zod schema.
-   *
-   * Failure is `invalid_response`: "our own response schema did not match",
-   * never "the user's input was rejected". No Zod issues are attached: they
-   * embed the offending response data.
-   */
-  validate(data, schema) {
-    const result = schema.safeParse(data);
-    if (!result.success) {
-      return Err({
-        kind: "invalid_response",
-        message: "The server response did not match the expected schema."
-      });
-    }
-    return Ok(result.data);
-  }
-  /**
-   * Validate caller-supplied input before it reaches the network.
-   *
-   * Failure is `invalid_request` and has no `status`: nothing was sent.
-   */
-  validateInput(input, schema) {
-    const result = schema.safeParse(input);
-    if (!result.success) {
-      return Err({
-        kind: "invalid_request",
-        message: "The request input did not match the expected schema."
-      });
-    }
-    return Ok(result.data);
-  }
-  /**
-   * The boundary. Runs `send`, converts a transport failure into an `Err`, and
-   * hands the `Response` to `read`.
-   *
-   * Anything thrown that is not the internal carrier is a programming error and
-   * is rethrown.
-   */
-  async requestResponse(send, read) {
-    let response;
-    try {
-      response = await send();
-    } catch (error) {
-      if (isTransportFailure(error)) {
-        return Err(error.rustrakError);
-      }
-      throw error;
-    }
-    return read(response);
-  }
-  /**
-   * Read a JSON body, mapping a failed read onto the right `kind`.
-   *
-   * Shared with `AuthResource`, which needs the `Set-Cookie` headers off the
-   * raw `Response` and so cannot go through {@link BaseResource.request}.
-   */
-  async readJson(response) {
-    try {
-      return Ok(await response.json());
-    } catch (error) {
-      const failure = classifyBodyFailure(error);
-      if (failure === "rethrow") {
-        throw error;
-      }
-      return Err(failure);
-    }
-  }
-  /** Send a request and validate its JSON body against `schema`. */
-  async request(send, schema) {
-    return this.requestResponse(send, async (response) => {
-      const body = await this.readJson(response);
-      if (!body.success) {
-        return body;
-      }
-      return this.validate(body.data, schema);
-    });
-  }
-  /** Send a request whose response body carries no contract (204, or ignored). */
-  async requestVoid(send) {
-    return this.requestResponse(send, async (response) => {
-      discardBody(response);
-      return Ok(void 0);
-    });
-  }
-};
-
-// src/resources/agents.ts
-function timeseriesSearchParams(options) {
-  const searchParams = {};
-  if (options?.period_hours) {
-    searchParams.period_hours = String(options.period_hours);
-  }
-  if (options?.interval_hours) {
-    searchParams.interval_hours = String(options.interval_hours);
-  }
-  if (options?.environment) {
-    searchParams.environment = options.environment;
-  }
-  return searchParams;
-}
-function breakdownSearchParams(options) {
-  const searchParams = {};
-  if (options?.period_hours) {
-    searchParams.period_hours = String(options.period_hours);
-  }
-  if (options?.limit) {
-    searchParams.limit = String(options.limit);
-  }
-  if (options?.environment) {
-    searchParams.environment = options.environment;
-  }
-  return searchParams;
-}
-var AgentsResource = class extends BaseResource {
-  /**
-   * Time-bucketed count of agent-run spans (`gen_ai.operation.type:agent`).
-   */
-  async getRuns(projectId, options) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/agents/runs`, {
-        searchParams: timeseriesSearchParams(options)
-      }),
-      z.array(agentTimeseriesPointSchema)
-    );
-  }
-  /**
-   * Time-bucketed avg/p95 duration for `agent`/`ai_client` spans.
-   */
-  async getDuration(projectId, options) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/agents/duration`, {
-        searchParams: timeseriesSearchParams(options)
-      }),
-      z.array(agentDurationPointSchema)
-    );
-  }
-  /**
-   * Top models by LLM call count (`gen_ai.operation.type:ai_client`).
-   */
-  async getModelsByCalls(projectId, options) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/agents/models/calls`, {
-        searchParams: breakdownSearchParams(options)
-      }),
-      z.array(genAiBreakdownRowSchema)
-    );
-  }
-  /**
-   * Top models by total tokens used (`gen_ai.operation.type:ai_client`).
-   */
-  async getModelsByTokens(projectId, options) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/agents/models/tokens`, {
-        searchParams: breakdownSearchParams(options)
-      }),
-      z.array(genAiBreakdownRowSchema)
-    );
-  }
-  /**
-   * Top tools by call count (`gen_ai.operation.type:tool`).
-   */
-  async getTools(projectId, options) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/agents/tools`, {
-        searchParams: breakdownSearchParams(options)
-      }),
-      z.array(genAiBreakdownRowSchema)
-    );
-  }
-  /**
-   * Paginated per-trace_id aggregate (duration, tokens, tool usage) across
-   * all AI spans sharing that trace, regardless of origin.
-   */
-  async getTraces(projectId, options) {
-    const searchParams = {};
-    if (options?.page) {
-      searchParams.page = String(options.page);
-    }
-    if (options?.per_page) {
-      searchParams.per_page = String(options.per_page);
-    }
-    if (options?.period_hours) {
-      searchParams.period_hours = String(options.period_hours);
-    }
-    if (options?.environment) {
-      searchParams.environment = options.environment;
-    }
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/agents/traces`, {
-        searchParams
-      }),
-      offsetPaginatedResponseSchema(agentTraceSummarySchema)
-    );
-  }
-  /**
-   * Headline totals over the selected window — the numbers the charts show
-   * the shape of but cannot state.
-   */
-  async getSummary(projectId, options) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/agents/summary`, {
-        searchParams: breakdownSearchParams(options)
-      }),
-      agentSummarySchema
-    );
-  }
-  /**
-   * Per-model table: volume, failures, latency and the full token split.
-   */
-  async getModelsTable(projectId, options) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/agents/models`, {
-        searchParams: breakdownSearchParams(options)
-      }),
-      z.array(agentModelRowSchema)
-    );
-  }
-  /**
-   * Per-tool table: call volume, failures and latency.
-   */
-  async getToolsTable(projectId, options) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/agents/tools/stats`, {
-        searchParams: breakdownSearchParams(options)
-      }),
-      z.array(agentToolRowSchema)
-    );
-  }
-  /**
-   * Environments present in this project's AI spans — the options the filter
-   * offers, read from the data rather than hardcoded.
-   */
-  async getEnvironments(projectId) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/agents/environments`),
-      z.array(z.string())
-    );
-  }
-};
-var AlertIntegrationsResource = class extends BaseResource {
-  /**
-   * List all alert integrations
-   */
-  async list() {
-    return this.request(
-      () => this.http.get("api/integrations"),
-      z.array(alertIntegrationSchema)
-    );
-  }
-  /**
-   * Get a single alert integration by ID
-   */
-  async get(id) {
-    return this.request(
-      () => this.http.get(`api/integrations/${id}`),
-      alertIntegrationSchema
-    );
-  }
-  /**
-   * Create a new alert integration
-   */
-  async create(input) {
-    const validatedInput = this.validateInput(
-      input,
-      createAlertIntegrationSchema
-    );
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.post("api/integrations", { json: validatedInput.data }),
-      alertIntegrationSchema
-    );
-  }
-  /**
-   * Update an existing alert integration
-   */
-  async update(id, input) {
-    const validatedInput = this.validateInput(
-      input,
-      updateAlertIntegrationSchema
-    );
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.patch(`api/integrations/${id}`, {
-        json: validatedInput.data
-      }),
-      alertIntegrationSchema
-    );
-  }
-  /**
-   * Delete an alert integration
-   */
-  async delete(id) {
-    return this.requestVoid(() => this.http.delete(`api/integrations/${id}`));
-  }
-  /**
-   * Send a test notification to verify integration configuration.
-   * For Slack bot_token integrations, routingOverride must include `channel`.
-   */
-  async test(id, routingOverride) {
-    let body;
-    if (routingOverride !== void 0) {
-      const validatedInput = this.validateInput(
-        { routing_override: routingOverride },
-        testIntegrationBodySchema
-      );
-      if (!validatedInput.success) {
-        return validatedInput;
-      }
-      body = validatedInput.data;
-    }
-    return this.request(
-      () => this.http.post(
-        `api/integrations/${id}/test`,
-        body !== void 0 ? { json: body } : void 0
-      ),
-      testChannelResponseSchema
-    );
-  }
-  /**
-   * Render a Custom Webhook template against a sample payload.
-   *
-   * Answers with the body that would be sent, or with why it would not
-   * render. It goes to the server because the server owns the template
-   * engine: a preview computed anywhere else would eventually disagree with
-   * what a delivery actually sends.
-   */
-  async previewTemplate(template) {
-    return this.request(
-      () => this.http.post("api/integrations/preview-template", {
-        json: { template }
-      }),
-      previewTemplateResponseSchema
-    );
-  }
-};
-var AlertRulesResource = class extends BaseResource {
-  /**
-   * List all alert rules for a project
-   */
-  async list(projectId) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/alert-rules`),
-      z.array(alertRuleSchema)
-    );
-  }
-  /**
-   * Get a single alert rule by ID
-   */
-  async get(projectId, ruleId) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/alert-rules/${ruleId}`),
-      alertRuleSchema
-    );
-  }
-  /**
-   * Create a new alert rule for a project
-   */
-  async create(projectId, input) {
-    const validatedInput = this.validateInput(input, createAlertRuleSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.post(`api/projects/${projectId}/alert-rules`, {
-        json: validatedInput.data
-      }),
-      alertRuleSchema
-    );
-  }
-  /**
-   * Update an existing alert rule
-   */
-  async update(projectId, ruleId, input) {
-    const validatedInput = this.validateInput(input, updateAlertRuleSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.patch(`api/projects/${projectId}/alert-rules/${ruleId}`, {
-        json: validatedInput.data
-      }),
-      alertRuleSchema
-    );
-  }
-  /**
-   * Delete an alert rule
-   */
-  async delete(projectId, ruleId) {
-    return this.requestVoid(
-      () => this.http.delete(`api/projects/${projectId}/alert-rules/${ruleId}`)
-    );
-  }
-  /**
-   * List alert history for a project
-   */
-  async listHistory(projectId, options) {
-    const searchParams = new URLSearchParams();
-    if (options?.limit !== void 0) {
-      searchParams.set("limit", options.limit.toString());
-    }
-    const query = searchParams.toString();
-    const url = query ? `api/projects/${projectId}/alert-history?${query}` : `api/projects/${projectId}/alert-history`;
-    return this.request(() => this.http.get(url), z.array(alertHistorySchema));
-  }
-};
-
-// src/resources/auth.ts
-function readSetCookie(response) {
-  if (typeof response.headers.getSetCookie === "function") {
-    return response.headers.getSetCookie();
-  }
-  const folded = response.headers.get("set-cookie");
-  return folded === null ? [] : [folded];
-}
-var AuthResource = class extends BaseResource {
-  /** Return the public SSO login configuration. */
-  async getSsoConfig() {
-    return this.request(
-      () => this.http.get("auth/sso/config"),
-      ssoConfigSchema
-    );
-  }
-  /** Begin SSO and return the provider URL plus the encrypted state cookie. */
-  async startSso() {
-    return this.requestResponse(
-      () => this.http.post("auth/sso/start"),
-      async (response) => {
-        const cookies = readSetCookie(response);
-        const body = await this.readJson(response);
-        if (!body.success) return body;
-        const data = this.validate(body.data, ssoStartSchema);
-        if (!data.success) return data;
-        return Ok({
-          authorizationUrl: data.data.authorization_url,
-          cookies
-        });
-      }
-    );
-  }
-  /** The account an SSO login is waiting to link, if any. */
-  async getSsoLink() {
-    return this.request(() => this.http.get("auth/sso/link"), ssoLinkSchema);
-  }
-  /** Link the pending SSO identity with the account's password and sign in. */
-  async confirmSsoLink(password) {
-    const validatedInput = this.validateInput(
-      { password },
-      confirmSsoLinkRequestSchema
-    );
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.requestResponse(
-      () => this.http.post("auth/sso/link", { json: validatedInput.data }),
-      (response) => this.readLoginResult(response)
-    );
-  }
-  /** Complete an OIDC callback and return the normal Rustrak session cookie. */
-  async completeSso(callback) {
-    const searchParams = new URLSearchParams();
-    if (callback.code) searchParams.set("code", callback.code);
-    if (callback.state) searchParams.set("state", callback.state);
-    if (callback.error) searchParams.set("error", callback.error);
-    return this.requestResponse(
-      () => this.http.get("auth/sso/callback", { searchParams }),
-      (response) => this.readLoginResult(response)
-    );
-  }
-  /**
-   * Register a new user account
-   * Creates a new user and automatically logs them in (sets session cookie)
-   * @param credentials - Email and password for the new account
-   * @returns LoginResult with user information and session cookies
-   */
-  async register(credentials) {
-    const validatedInput = this.validateInput(
-      credentials,
-      registerRequestSchema
-    );
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.requestResponse(
-      () => this.http.post("auth/register", { json: validatedInput.data }),
-      (response) => this.readLoginResult(response)
-    );
-  }
-  /**
-   * Login with email and password
-   * Authenticates the user and sets a session cookie
-   * @param credentials - Email and password
-   * @returns LoginResult with user information and session cookies
-   */
-  async login(credentials) {
-    const validatedInput = this.validateInput(credentials, loginRequestSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.requestResponse(
-      () => this.http.post("auth/login", { json: validatedInput.data }),
-      (response) => this.readLoginResult(response)
-    );
-  }
-  /**
-   * Logout the current user
-   * Clears the session cookie
-   * @returns Array of Set-Cookie headers (typically clearing cookies)
-   */
-  async logout() {
-    return this.requestResponse(
-      () => this.http.post("auth/logout"),
-      async (response) => {
-        const cookies = readSetCookie(response);
-        discardBody(response);
-        return Ok(cookies);
-      }
-    );
-  }
-  /**
-   * Get current authenticated user
-   * Requires a valid session cookie
-   *
-   * No session is `{success: false, kind: 'unauthenticated'}`, not a `null`
-   * user: it is the literal reading of the server's 401. Callers must send the
-   * visitor to login on `unauthenticated` **only**. Treating `network` or
-   * `server_error` the same way turns a flaky connection into a login loop.
-   *
-   * @returns The current user, or `unauthenticated` when there is no session
-   */
-  async getCurrentUser() {
-    return this.request(() => this.http.get("auth/me"), userSchema);
-  }
-  /**
-   * Stores how this reader wants the dashboard presented to them.
-   *
-   * A key left out is left alone; a key sent as `null` is cleared. That is why
-   * the request type is optional *and* nullable rather than one or the other:
-   * "do not touch" and "forget my choice" are different instructions.
-   */
-  async updatePreferences(preferences) {
-    const validatedInput = this.validateInput(
-      preferences,
-      updatePreferencesRequestSchema
-    );
-    if (!validatedInput.success) return validatedInput;
-    return this.request(
-      () => this.http.patch("auth/me", { json: validatedInput.data }),
-      userSchema
-    );
-  }
-  /** Replaces the signed-in user's password, given the current one. */
-  async changePassword(request) {
-    const validatedInput = this.validateInput(
-      request,
-      changePasswordRequestSchema
-    );
-    if (!validatedInput.success) return validatedInput;
-    return this.requestVoid(
-      () => this.http.post("auth/me/password", {
-        json: validatedInput.data,
-        retry: 0
-      })
-    );
-  }
-  /**
-   * Get the details of a pending invitation by its token (public endpoint)
-   * Used by the accept-invitation page before the user has an account
-   * @param token - Invitation token
-   * @returns Invitation info (email, role, status, expiry)
-   */
-  async getInvitation(token) {
-    return this.request(
-      () => this.http.get(`auth/invitation/${token}`),
-      invitationInfoSchema
-    );
-  }
-  /**
-   * Accept a pending invitation, creating the user account and logging in
-   * @param input - Invitation token and the new account's password
-   * @returns LoginResult with user information and session cookies
-   */
-  async acceptInvitation(input) {
-    const validatedInput = this.validateInput(input, acceptInvitationSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.requestResponse(
-      () => this.http.post("auth/accept-invitation", {
-        json: validatedInput.data
-      }),
-      (response) => this.readLoginResult(response)
-    );
-  }
-  /**
-   * The three session-establishing endpoints share a body and need the
-   * `Set-Cookie` headers off the raw `Response`, which is why they go through
-   * `requestResponse` rather than the plain JSON path.
-   */
-  async readLoginResult(response) {
-    const cookies = readSetCookie(response);
-    const body = await this.readJson(response);
-    if (!body.success) {
-      return body;
-    }
-    const authResponse = this.validate(body.data, authResponseSchema);
-    if (!authResponse.success) {
-      return authResponse;
-    }
-    return Ok({ user: authResponse.data.user, cookies });
-  }
-};
-
-// src/resources/events.ts
-var EventsResource = class extends BaseResource {
-  /**
-   * List events for an issue with pagination
-   */
-  async list(projectId, issueId, options) {
-    const searchParams = {};
-    if (options?.order) {
-      searchParams.order = options.order;
-    }
-    if (options?.cursor) {
-      searchParams.cursor = options.cursor;
-    }
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/issues/${issueId}/events`, {
-        searchParams
-      }),
-      paginatedResponseSchema(eventSchema)
-    );
-  }
-  /**
-   * Get a single event by ID with full details
-   */
-  async get(projectId, issueId, eventId) {
-    return this.request(
-      () => this.http.get(
-        `api/projects/${projectId}/issues/${issueId}/events/${eventId}`
-      ),
-      eventDetailSchema
-    );
-  }
-  /** Resolve the client-supplied Sentry event ID, including its owning issue. */
-  async getBySentryId(projectId, eventId) {
-    return this.request(
-      () => this.http.get(
-        `api/projects/${projectId}/events/sentry/${encodeURIComponent(eventId)}`
-      ),
-      eventDetailSchema
-    );
-  }
-};
-
-// src/resources/github.ts
-var GitHubResource = class extends BaseResource {
-  /** The app, its installations and the webhook address (admin only). */
-  async status() {
-    return this.request(() => this.http.get("api/github"), gitHubStatusSchema);
-  }
-  /** The form to post to GitHub to create the app, under an org if given. */
-  async manifest(organization) {
-    return this.request(
-      () => this.http.post("api/github/manifest", { json: { organization } }),
-      gitHubManifestSchema
-    );
-  }
-  async disconnect() {
-    return this.requestVoid(() => this.http.delete("api/github"));
-  }
-  /** Repositories the installations reach, for a project's settings. */
-  async repositories(projectId) {
-    return this.request(
-      () => this.http.get("api/github/repositories", {
-        searchParams: { project_id: projectId }
-      }),
-      gitHubRepositorySchema.array()
-    );
-  }
-  async projectRepository(projectId) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/github`),
-      projectRepositorySchema.nullable()
-    );
-  }
-  async setProjectRepository(projectId, input) {
-    const validated = this.validateInput(input, updateProjectRepositorySchema);
-    if (!validated.success) {
-      return validated;
-    }
-    return this.request(
-      () => this.http.put(`api/projects/${projectId}/github`, {
-        json: validated.data
-      }),
-      projectRepositorySchema
-    );
-  }
-  async removeProjectRepository(projectId) {
-    return this.requestVoid(
-      () => this.http.delete(`api/projects/${projectId}/github`)
-    );
-  }
-  /** Copies the repository's CODEOWNERS into Rustrak. */
-  async syncCodeowners(projectId) {
-    return this.request(
-      () => this.http.post(`api/projects/${projectId}/github/codeowners`),
-      projectRepositorySchema
-    );
-  }
-  /** Links, suspect commits and owners for one issue. */
-  async issue(projectId, issueId) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/issues/${issueId}/github`),
-      issueGitHubSchema
-    );
-  }
-  async createIssue(projectId, issueId, input = {}) {
-    return this.request(
-      () => this.http.post(
-        `api/projects/${projectId}/issues/${issueId}/github/issues`,
-        { json: input }
-      ),
-      issueLinkSchema
-    );
-  }
-  /** `reference` is a GitHub URL, `owner/repo#12` or `#12`. */
-  async linkIssue(projectId, issueId, reference) {
-    return this.request(
-      () => this.http.post(
-        `api/projects/${projectId}/issues/${issueId}/github/links`,
-        { json: { reference } }
-      ),
-      issueLinkSchema
-    );
-  }
-  async unlinkIssue(projectId, issueId, linkId) {
-    return this.requestVoid(
-      () => this.http.delete(
-        `api/projects/${projectId}/issues/${issueId}/github/links/${linkId}`
-      )
-    );
-  }
-  /** The signed-in person's GitHub username, used to sync assignees. */
-  async myLogin() {
-    return this.request(
-      () => this.http.get("api/github/me"),
-      gitHubLoginSchema
-    );
-  }
-  async setMyLogin(login) {
-    return this.request(
-      () => this.http.put("api/github/me", { json: { login } }),
-      gitHubLoginSchema
-    );
-  }
-};
-var serverVersionSchema = z.object({
-  version: z.string()
-});
-
-// src/resources/health.ts
-var HealthResource = class extends BaseResource {
-  /**
-   * The version the server reports for itself.
-   *
-   * Authenticated: the server answers this one to a session or a Bearer token
-   * only, and returns 401 to anonymous callers. `/health` and `/health/ready`
-   * stay open for probes; a version number is what tells a stranger which
-   * advisories apply to your instance, so it is not probe material.
-   */
-  async getVersion() {
-    return this.request(
-      () => this.http.get("health/version"),
-      serverVersionSchema
-    );
-  }
-};
-
-// src/resources/invitations.ts
-var InvitationsResource = class extends BaseResource {
-  /**
-   * Create a new invitation
-   * @param input - Email and global role for the invited user
-   */
-  async create(input) {
-    const validatedInput = this.validateInput(input, createInvitationSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.post("api/invitations", { json: validatedInput.data }),
-      invitationSchema
-    );
-  }
-  /**
-   * List all invitations
-   */
-  async list() {
-    return this.request(
-      () => this.http.get("api/invitations"),
-      invitationSchema.array()
-    );
-  }
-  /**
-   * Revoke a pending invitation
-   * @param token - Invitation token to revoke
-   */
-  async revoke(token) {
-    return this.requestVoid(() => this.http.delete(`api/invitations/${token}`));
-  }
-};
-var IssuesResource = class extends BaseResource {
-  /**
-   * List issues for a project with offset-based pagination
-   */
-  async list(projectId, options) {
-    const searchParams = {};
-    if (options?.page !== void 0) {
-      searchParams.page = options.page.toString();
-    }
-    if (options?.per_page !== void 0) {
-      searchParams.per_page = options.per_page.toString();
-    }
-    if (options?.sort) {
-      searchParams.sort = options.sort;
-    }
-    if (options?.order) {
-      searchParams.order = options.order;
-    }
-    if (options?.filter) {
-      searchParams.filter = options.filter;
-    }
-    if (options?.q) {
-      searchParams.q = options.q;
-    }
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/issues`, { searchParams }),
-      offsetPaginatedResponseSchema(issueSchema)
-    );
-  }
-  /**
-   * Get a single issue by ID
-   */
-  async get(projectId, issueId) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/issues/${issueId}`),
-      issueSchema
-    );
-  }
-  /**
-   * Update issue state (status, substatus, priority, assignment, …)
-   */
-  async updateState(projectId, issueId, input) {
-    const validatedInput = this.validateInput(input, updateIssueStateSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.patch(`api/projects/${projectId}/issues/${issueId}`, {
-        json: validatedInput.data
-      }),
-      issueSchema
-    );
-  }
-  /**
-   * Resolve an issue in the next release (suppresses regression until a deploy).
-   */
-  async resolveInNextRelease(projectId, issueId) {
-    return this.updateState(projectId, issueId, {
-      status: "resolvedInNextRelease"
-    });
-  }
-  /**
-   * Delete an issue
-   */
-  async delete(projectId, issueId) {
-    return this.requestVoid(
-      () => this.http.delete(`api/projects/${projectId}/issues/${issueId}`)
-    );
-  }
-  /**
-   * Bulk-mutate issues (status and/or priority).
-   */
-  async bulkUpdate(projectId, input) {
-    const validatedInput = this.validateInput(input, bulkUpdateIssuesSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.put(`api/projects/${projectId}/issues`, {
-        json: validatedInput.data
-      }),
-      z.object({ updated: z.number().int() })
-    );
-  }
-  /**
-   * Bulk-delete issues.
-   */
-  async bulkDelete(projectId, input) {
-    const validatedInput = this.validateInput(input, bulkDeleteIssuesSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.delete(`api/projects/${projectId}/issues`, {
-        json: validatedInput.data
-      }),
-      z.object({ deleted: z.number().int() })
-    );
-  }
-  /**
-   * List the grouping hashes that map to an issue.
-   */
-  async getHashes(projectId, issueId) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/issues/${issueId}/hashes`),
-      z.array(issueHashSchema)
-    );
-  }
-  /**
-   * List the distinct values (with counts) for a tag key across the issue.
-   * Returns a bare list, one entry per value (Sentry-compatible shape).
-   */
-  async getTagValues(projectId, issueId, key) {
-    return this.request(
-      () => this.http.get(
-        `api/projects/${projectId}/issues/${issueId}/tags/${encodeURIComponent(key)}`
-      ),
-      z.array(issueTagValueSchema)
-    );
-  }
-  /**
-   * Fetch per-issue aggregates (unique user count + top tags).
-   */
-  async getAggregates(projectId, issueId) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/issues/${issueId}/aggregates`),
-      issueAggregatesSchema
-    );
-  }
-  /**
-   * Fetch a zero-filled event-count timeseries (24h or 30d).
-   */
-  async getStats(projectId, issueId, window = "24h") {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/issues/${issueId}/stats`, {
-        searchParams: { window }
-      }),
-      issueStatsSchema
-    );
-  }
-  /**
-   * List an issue's activity log (status changes, comments/notes, …).
-   */
-  async getActivity(projectId, issueId) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/issues/${issueId}/activity`),
-      z.array(activityEntrySchema)
-    );
-  }
-  /**
-   * Add a comment (note) to an issue.
-   */
-  async addComment(projectId, issueId, input) {
-    const validatedInput = this.validateInput(input, createCommentSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.post(`api/projects/${projectId}/issues/${issueId}/comments`, {
-        json: validatedInput.data
-      }),
-      activityEntrySchema
-    );
-  }
-  /**
-   * Set or clear the current user's bookmark on an issue.
-   */
-  async setBookmark(projectId, issueId, enabled) {
-    return this.request(
-      () => this.http.put(`api/projects/${projectId}/issues/${issueId}/bookmark`, {
-        json: { enabled }
-      }),
-      z.object({ is_bookmarked: z.boolean() })
-    );
-  }
-  /**
-   * Set or clear the current user's subscription to an issue.
-   */
-  async setSubscription(projectId, issueId, enabled) {
-    return this.request(
-      () => this.http.put(
-        `api/projects/${projectId}/issues/${issueId}/subscription`,
-        { json: { enabled } }
-      ),
-      z.object({ is_subscribed: z.boolean() })
-    );
-  }
-  /**
-   * Mark the issue as seen by the current user.
-   */
-  async markSeen(projectId, issueId) {
-    return this.request(
-      () => this.http.post(`api/projects/${projectId}/issues/${issueId}/seen`),
-      z.object({ has_seen: z.boolean() })
-    );
-  }
-  /**
-   * List user feedback reports for an issue.
-   */
-  async listUserReports(projectId, issueId) {
-    return this.request(
-      () => this.http.get(
-        `api/projects/${projectId}/issues/${issueId}/user-reports`
-      ),
-      z.array(userReportSchema)
-    );
-  }
-  /**
-   * Attach a user feedback report to an issue.
-   */
-  async createUserReport(projectId, issueId, input) {
-    const validatedInput = this.validateInput(input, createUserReportSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.post(
-        `api/projects/${projectId}/issues/${issueId}/user-reports`,
-        { json: validatedInput.data }
-      ),
-      userReportSchema
-    );
-  }
-};
-
-// src/resources/logs.ts
-var LogsResource = class extends BaseResource {
-  /**
-   * List logs for a project with offset-based pagination (newest first by log
-   * timestamp), optionally filtered by level/trace_id.
-   */
-  async list(projectId, options) {
-    const searchParams = {};
-    if (options?.page) {
-      searchParams.page = String(options.page);
-    }
-    if (options?.per_page) {
-      searchParams.per_page = String(options.per_page);
-    }
-    if (options?.level) {
-      searchParams.level = options.level;
-    }
-    if (options?.trace_id) {
-      searchParams.trace_id = options.trace_id;
-    }
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/logs`, { searchParams }),
-      offsetPaginatedResponseSchema(logSchema)
-    );
-  }
-};
-
-// src/resources/members.ts
-var MembersResource = class extends BaseResource {
-  /**
-   * List members of a project
-   * @param projectId - ID of the project
-   */
-  async list(projectId) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/members`),
-      projectMemberSchema.array()
-    );
-  }
-  /**
-   * Add or update a project member
-   * @param projectId - ID of the project
-   * @param input - User ID and per-project role
-   */
-  async upsert(projectId, input) {
-    const validatedInput = this.validateInput(input, upsertProjectMemberSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.requestVoid(
-      () => this.http.put(`api/projects/${projectId}/members`, {
-        json: validatedInput.data
-      })
-    );
-  }
-  /**
-   * Remove a member from a project
-   * @param projectId - ID of the project
-   * @param userId - ID of the user to remove
-   */
-  async remove(projectId, userId) {
-    return this.requestVoid(
-      () => this.http.delete(`api/projects/${projectId}/members/${userId}`)
-    );
-  }
-};
-var MonitorsResource = class extends BaseResource {
-  /** Every monitor of a project, with its environments and recent check-ins. */
-  async list(projectId) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/monitors`),
-      z.array(monitorSchema)
-    );
-  }
-  async get(projectId, slug) {
-    return this.request(
-      () => this.http.get(
-        `api/projects/${projectId}/monitors/${encodeURIComponent(slug)}`
-      ),
-      monitorSchema
-    );
-  }
-  async create(projectId, input) {
-    const validated = this.validateInput(input, createMonitorSchema);
-    if (!validated.success) {
-      return validated;
-    }
-    return this.request(
-      () => this.http.post(`api/projects/${projectId}/monitors`, {
-        json: validated.data
-      }),
-      monitorSchema
-    );
-  }
-  /** Fields left out keep their value, including each field of `config`. */
-  async update(projectId, slug, input) {
-    const validated = this.validateInput(input, updateMonitorSchema);
-    if (!validated.success) {
-      return validated;
-    }
-    return this.request(
-      () => this.http.put(
-        `api/projects/${projectId}/monitors/${encodeURIComponent(slug)}`,
-        { json: validated.data }
-      ),
-      monitorSchema
-    );
-  }
-  /** Deletes the monitor and its check-ins. Its issues stay. */
-  async delete(projectId, slug) {
-    return this.requestVoid(
-      () => this.http.delete(
-        `api/projects/${projectId}/monitors/${encodeURIComponent(slug)}`
-      )
-    );
-  }
-  /** Check-ins of one monitor, newest first. */
-  async listCheckIns(projectId, slug, options) {
-    const searchParams = {};
-    if (options?.page) {
-      searchParams.page = String(options.page);
-    }
-    if (options?.per_page) {
-      searchParams.per_page = String(options.per_page);
-    }
-    if (options?.environment) {
-      searchParams.environment = options.environment;
-    }
-    return this.request(
-      () => this.http.get(
-        `api/projects/${projectId}/monitors/${encodeURIComponent(slug)}/checkins`,
-        { searchParams }
-      ),
-      offsetPaginatedResponseSchema(checkInSchema)
-    );
-  }
-};
-
-// src/resources/projects.ts
-var ProjectsResource = class extends BaseResource {
-  /**
-   * List projects with pagination
-   */
-  async list(options) {
-    const searchParams = new URLSearchParams();
-    if (options?.page !== void 0) {
-      searchParams.set("page", options.page.toString());
-    }
-    if (options?.per_page !== void 0) {
-      searchParams.set("per_page", options.per_page.toString());
-    }
-    if (options?.order) {
-      searchParams.set("order", options.order);
-    }
-    if (options?.stats_period) {
-      searchParams.set("stats_period", options.stats_period);
-    }
-    const query = searchParams.toString();
-    const url = query ? `api/projects?${query}` : "api/projects";
-    return this.request(
-      () => this.http.get(url),
-      offsetPaginatedResponseSchema(projectSchema)
-    );
-  }
-  /**
-   * The server's per-project limits, which a project without its own follows
-   */
-  async rateLimits() {
-    return this.request(
-      () => this.http.get("api/rate-limits"),
-      rateLimitsSchema
-    );
-  }
-  /**
-   * Get a single project by ID
-   */
-  async get(id) {
-    return this.request(
-      () => this.http.get(`api/projects/${id}`),
-      projectSchema
-    );
-  }
-  /**
-   * Create a new project
-   */
-  async create(input) {
-    const validatedInput = this.validateInput(input, createProjectSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.post("api/projects", { json: validatedInput.data }),
-      projectSchema
-    );
-  }
-  /**
-   * Update an existing project
-   */
-  async update(id, input) {
-    const validatedInput = this.validateInput(input, updateProjectSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.patch(`api/projects/${id}`, { json: validatedInput.data }),
-      projectSchema
-    );
-  }
-  /**
-   * Delete a project
-   */
-  async delete(id) {
-    return this.requestVoid(() => this.http.delete(`api/projects/${id}`));
-  }
-};
-var ReleasesResource = class extends BaseResource {
-  /**
-   * Get issues first seen in a given release, most recently introduced first.
-   *
-   * @param projectId - Project ID
-   * @param release - Release version
-   * @param limit - Max issues to return (default: 10, max: 50)
-   */
-  async newIssues(projectId, release, limit) {
-    const searchParams = {};
-    if (limit !== void 0) {
-      searchParams.limit = limit.toString();
-    }
-    return this.request(
-      () => this.http.get(
-        `api/projects/${projectId}/releases/${encodeURIComponent(release)}/new-issues`,
-        { searchParams }
-      ),
-      z.array(issueSchema)
-    );
-  }
-};
-
-// src/resources/schedules.ts
-var SchedulesResource = class extends BaseResource {
-  /** Validates a schedule and lists its next five runs. */
-  async preview(input) {
-    const validated = this.validateInput(input, previewScheduleSchema);
-    if (!validated.success) {
-      return validated;
-    }
-    return this.request(
-      () => this.http.post("api/schedules/preview", { json: validated.data }),
-      schedulePreviewSchema
-    );
-  }
-};
-
-// src/resources/sessions.ts
-var SessionsResource = class extends BaseResource {
-  /**
-   * Get per-release health stats for a project, one offset-based page of
-   * (release, environment) rows at a time, ordered by session volume.
-   * @param projectId - Project ID
-   * @param options - Time window, release scoping and pagination.
-   */
-  async stats(projectId, options) {
-    const searchParams = {};
-    if (options?.period) {
-      searchParams.period = options.period;
-    }
-    if (options?.release) {
-      searchParams.release = options.release;
-    }
-    if (options?.page) {
-      searchParams.page = String(options.page);
-    }
-    if (options?.per_page) {
-      searchParams.per_page = String(options.per_page);
-    }
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/sessions/stats`, {
-        searchParams
-      }),
-      offsetPaginatedResponseSchema(releaseHealthRowSchema)
-    );
-  }
-  /**
-   * Get project-wide session health, aggregated across all releases and environments.
-   * @param projectId - Project ID
-   * @param period - Time window (e.g. '24h', '7d'). Defaults to '24h'.
-   */
-  async summary(projectId, period) {
-    const searchParams = {};
-    if (period) {
-      searchParams.period = period;
-    }
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/sessions/summary`, {
-        searchParams
-      }),
-      sessionSummarySchema
-    );
-  }
-  /**
-   * Get a time-bucketed session trend for a project, aggregated across all
-   * releases and environments.
-   * @param projectId - Project ID
-   * @param period - Time window (e.g. '24h', '7d'). Defaults to '24h'.
-   * @param interval - Bucket width in hours (default: 1, max: 24).
-   */
-  async timeseries(projectId, period, interval) {
-    const searchParams = {};
-    if (period) {
-      searchParams.period = period;
-    }
-    if (interval !== void 0) {
-      searchParams.interval = interval.toString();
-    }
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/sessions/timeseries`, {
-        searchParams
-      }),
-      sessionTimeseriesSchema
-    );
-  }
-};
-
-// src/resources/sourcemaps.ts
-var SourceMapsResource = class extends BaseResource {
-  /**
-   * Get chunk upload capabilities for an organization.
-   * Returns the upload URL, chunk size limits, and accepted artifact types.
-   */
-  async getChunkUploadCapability(orgSlug) {
-    return this.request(
-      () => this.http.get(`api/0/organizations/${orgSlug}/chunk-upload/`),
-      chunkUploadCapabilitySchema
-    );
-  }
-  /**
-   * Upload chunks as multipart/form-data, batching by `chunksPerRequest` (default 64).
-   * Each part's field name must be the pre-computed SHA-1 hash of its content — the server
-   * rejects mismatches with 400. Callers must supply the hash (also needed for assembleBundle).
-   */
-  async uploadChunks(orgSlug, chunks, chunksPerRequest = 64) {
-    if (!Number.isInteger(chunksPerRequest) || chunksPerRequest <= 0) {
-      return Err({
-        kind: "invalid_request",
-        message: "chunksPerRequest must be a positive integer."
-      });
-    }
-    for (let i = 0; i < chunks.length; i += chunksPerRequest) {
-      const batch = chunks.slice(i, i + chunksPerRequest);
-      const form = new FormData();
-      for (const chunk of batch) {
-        form.append(chunk.hash, chunk.data);
-      }
-      const uploaded = await this.requestVoid(
-        () => this.http.post(`api/0/organizations/${orgSlug}/chunk-upload/`, {
-          body: form
-        })
-      );
-      if (!uploaded.success) {
-        return uploaded;
-      }
-    }
-    return Ok(void 0);
-  }
-  /**
-   * Trigger assembly of a previously uploaded artifact bundle.
-   *
-   * @returns The assembly state. Poll until `state === "ok"` or `state === "error"`.
-   *          When `state === "not_found"` the `missingChunks` array lists what
-   *          still needs uploading via `uploadChunks`.
-   */
-  async assembleBundle(orgSlug, input) {
-    const validatedInput = this.validateInput(input, assembleInputSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.post(
-        `api/0/organizations/${orgSlug}/artifactbundle/assemble/`,
-        { json: validatedInput.data }
-      ),
-      assembleResponseSchema
-    );
-  }
-  /**
-   * List all source map files uploaded for a project.
-   */
-  async list(orgSlug, projectSlug) {
-    return this.request(
-      () => this.http.get(
-        `api/0/projects/${orgSlug}/${projectSlug}/files/source-maps/`
-      ),
-      listSourceMapsResponseSchema
-    );
-  }
-};
-
-// src/resources/spans.ts
-var SpansResource = class extends BaseResource {
-  /**
-   * List spans for a project with offset-based pagination (newest first),
-   * optionally filtered by op/status/trace_id/operation_type.
-   */
-  async list(projectId, options) {
-    const searchParams = {};
-    if (options?.page) {
-      searchParams.page = String(options.page);
-    }
-    if (options?.per_page) {
-      searchParams.per_page = String(options.per_page);
-    }
-    if (options?.op) {
-      searchParams.op = options.op;
-    }
-    if (options?.status) {
-      searchParams.status = options.status;
-    }
-    if (options?.trace_id) {
-      searchParams.trace_id = options.trace_id;
-    }
-    if (options?.operation_type) {
-      searchParams.operation_type = options.operation_type;
-    }
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/spans`, { searchParams }),
-      offsetPaginatedResponseSchema(spanSchema)
-    );
-  }
-  /**
-   * Fetch one span together with its raw attribute bag — the `gen_ai.*`
-   * payload (prompts, responses, tool arguments and results) that `list()`
-   * omits so a trace's worth of spans stays cheap to load.
-   *
-   * `spanId` is the row id from a list item's `id`, not the SDK's 16-hex
-   * `span_id`.
-   */
-  async get(projectId, spanId) {
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/spans/${spanId}`),
-      spanDetailSchema
-    );
-  }
-};
-
-// src/resources/stats.ts
-var StatsResource = class extends BaseResource {
-  /**
-   * Get time-bucketed error-event volume for a project, split by severity.
-   *
-   * Buckets are zero-filled across the window, so a quiet hour comes back as a
-   * point with `total: 0` rather than being absent. All-time requests (no
-   * `period`) are sparse: there is no lower bound to fill from.
-   *
-   * @param projectId - Project ID
-   * @param period - Time window (e.g. '24h', '7d'). Omit for all time.
-   * @param interval - Bucket width in hours (default: 1, max: 24).
-   */
-  async timeseries(projectId, period, interval) {
-    const searchParams = {};
-    if (period) {
-      searchParams.period = period;
-    }
-    if (interval !== void 0) {
-      searchParams.interval = interval.toString();
-    }
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/events/stats`, {
-        searchParams
-      }),
-      eventTimeseriesSchema
-    );
-  }
-  /**
-   * Get project-wide counters for a window, each paired with the same counter
-   * over the window immediately before it.
-   *
-   * @param projectId - Project ID
-   * @param period - Time window (e.g. '24h', '7d'). Omit for all time, which
-   *   leaves every `previous` null.
-   */
-  async summary(projectId, period) {
-    const searchParams = {};
-    if (period) {
-      searchParams.period = period;
-    }
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/stats/summary`, {
-        searchParams
-      }),
-      projectStatsSummarySchema
-    );
-  }
-};
-var StorageResource = class extends BaseResource {
-  /**
-   * Get the instance-wide storage summary: row counts per data category, the
-   * whole-DB size, and exact source-map weight.
-   */
-  async getSummary() {
-    return this.request(
-      () => this.http.get("api/storage/summary"),
-      storageSummarySchema
-    );
-  }
-  /**
-   * Get the per-project storage breakdown (one row per project, including
-   * empty ones).
-   */
-  async getProjects() {
-    return this.request(
-      () => this.http.get("api/storage/projects"),
-      z.array(projectStorageSchema)
-    );
-  }
-  /**
-   * Dry-run: count the rows a cleanup would remove. Mutates nothing — use it to
-   * confirm impact before {@link executeCleanup}.
-   */
-  async previewCleanup(options) {
-    const validatedInput = this.validateInput(options, cleanupOptionsSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.post("api/storage/cleanup/preview", {
-        json: validatedInput.data
-      }),
-      cleanupCountsSchema
-    );
-  }
-  /**
-   * Start a cleanup: delete data older than `older_than_days` (optionally
-   * scoped to one project) and remove the issues it leaves with zero events.
-   *
-   * Returns as soon as the server has started it, with the `running` status.
-   * The deletion runs in the background; follow it with
-   * {@link getCleanupStatus}. A second start while one is running fails with
-   * a `conflict`.
-   */
-  async executeCleanup(options) {
-    const validatedInput = this.validateInput(options, cleanupOptionsSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.post("api/storage/cleanup", {
-        json: validatedInput.data,
-        // No retry: if the first attempt started the cleanup and only its
-        // response was lost, a retry would be refused as a second run and
-        // report a failure for a cleanup that is in fact running.
-        retry: 0
-      }),
-      cleanupStatusSchema
-    );
-  }
-  /**
-   * The running cleanup's progress, or the outcome of the last one.
-   */
-  async getCleanupStatus() {
-    return this.request(
-      () => this.http.get("api/storage/cleanup/status"),
-      cleanupStatusSchema
-    );
-  }
-  /**
-   * Dry-run for {@link gcSourceMaps}: count the orphaned source-map files and
-   * bytes a GC would reclaim. Mutates nothing.
-   */
-  async previewGcSourceMaps() {
-    return this.request(
-      () => this.http.post("api/storage/source-maps/gc/preview"),
-      sourceMapGcResultSchema
-    );
-  }
-  /**
-   * Garbage-collect orphaned source maps: files no longer referenced by any
-   * upload, removed from the DB and unlinked from disk. Safe — never touches
-   * referenced files.
-   */
-  async gcSourceMaps() {
-    return this.request(
-      () => this.http.post("api/storage/source-maps/gc"),
-      sourceMapGcResultSchema
-    );
-  }
-  /**
-   * Retention: how long each kind of data is kept, by default and per
-   * project, when its cleanup runs next and how the last one went.
-   */
-  async getRetention() {
-    return this.request(
-      () => this.http.get("api/storage/retention"),
-      retentionSchema
-    );
-  }
-  /** Replaces the retention settings. A new schedule applies within a minute. */
-  async updateRetention(settings) {
-    const validated = this.validateInput(settings, retentionSettingsSchema);
-    if (!validated.success) {
-      return validated;
-    }
-    return this.request(
-      () => this.http.put("api/storage/retention", { json: validated.data }),
-      retentionSchema
-    );
-  }
-  /**
-   * Enforces the saved retention now, without waiting for the schedule, and
-   * deletes unused source maps. Returns the started job; follow it with
-   * {@link getCleanupStatus}. A `validation` error while everything is kept
-   * forever, `conflict` while a cleanup runs.
-   */
-  async runRetention() {
-    return this.request(
-      () => this.http.post("api/storage/retention/run", {
-        // No retry, as for `executeCleanup`: a lost response after the
-        // cleanup started would be retried into a refused second run.
-        retry: 0
-      }),
-      cleanupStatusSchema
-    );
-  }
-  /** How long ago each project's data arrived, per kind, in age buckets. */
-  async getAge() {
-    return this.request(
-      () => this.http.get("api/storage/age"),
-      storageAgeSchema
-    );
-  }
-  /**
-   * Dry-run: what enforcing these retention settings now would delete, each
-   * project against its own windows. Saves and deletes nothing.
-   */
-  async previewRetention(settings) {
-    const validated = this.validateInput(settings, retentionSettingsSchema);
-    if (!validated.success) {
-      return validated;
-    }
-    return this.request(
-      () => this.http.post("api/storage/retention/preview", {
-        json: validated.data
-      }),
-      cleanupCountsSchema
-    );
-  }
-};
-
-// src/resources/team.ts
-var TeamResource = class extends BaseResource {
-  /**
-   * List all team members (users)
-   */
-  async list() {
-    return this.request(
-      () => this.http.get("api/team"),
-      teamMemberSchema.array()
-    );
-  }
-  /**
-   * Change a user's global role
-   * @param userId - ID of the user to update
-   * @param role - New global role to assign
-   */
-  async updateRole(userId, role) {
-    const body = this.validateInput({ role }, updateUserRoleSchema);
-    if (!body.success) {
-      return body;
-    }
-    return this.requestVoid(
-      () => this.http.patch(`api/team/${userId}/role`, { json: body.data })
-    );
-  }
-  /**
-   * Permanently remove a user from the instance.
-   * @param userId - ID of the user to delete
-   */
-  async remove(userId) {
-    return this.requestVoid(() => this.http.delete(`api/team/${userId}`));
-  }
-};
-
-// src/resources/tokens.ts
-var TokensResource = class extends BaseResource {
-  /**
-   * List all auth tokens (masked)
-   */
-  async list() {
-    return this.request(
-      () => this.http.get("api/tokens"),
-      authTokenSchema.array()
-    );
-  }
-  /**
-   * Get a single auth token by ID (full token value).
-   *
-   * Previously returned a masked version, but the server now returns the
-   * complete token for GET /api/tokens/{id}.
-   */
-  async get(id) {
-    return this.request(
-      () => this.http.get(`api/tokens/${id}`),
-      authTokenCreatedSchema
-    );
-  }
-  /**
-   * Create a new auth token
-   * Note: The full token is only returned once during creation
-   */
-  async create(input) {
-    const validatedInput = this.validateInput(input, createAuthTokenSchema);
-    if (!validatedInput.success) {
-      return validatedInput;
-    }
-    return this.request(
-      () => this.http.post("api/tokens", { json: validatedInput.data }),
-      authTokenCreatedSchema
-    );
-  }
-  /**
-   * Delete an auth token
-   */
-  async delete(id) {
-    return this.requestVoid(() => this.http.delete(`api/tokens/${id}`));
-  }
-};
-var TransactionsResource = class extends BaseResource {
-  /**
-   * List transactions for a project with offset-based pagination (newest first)
-   */
-  async list(projectId, options) {
-    const searchParams = {};
-    if (options?.page) {
-      searchParams.page = String(options.page);
-    }
-    if (options?.per_page) {
-      searchParams.per_page = String(options.per_page);
-    }
-    if (options?.name) {
-      searchParams.name = options.name;
-    }
-    if (options?.op) {
-      searchParams.op = options.op;
-    }
-    if (options?.status) {
-      searchParams.status = options.status;
-    }
-    if (options?.environment) {
-      searchParams.environment = options.environment;
-    }
-    if (options?.release) {
-      searchParams.release = options.release;
-    }
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/transactions`, {
-        searchParams
-      }),
-      offsetPaginatedResponseSchema(transactionSchema)
-    );
-  }
-  /**
-   * Get the indexed spans extracted from a transaction, in waterfall order.
-   */
-  async getSpans(projectId, transactionId) {
-    return this.request(
-      () => this.http.get(
-        `api/projects/${projectId}/transactions/${transactionId}/spans`
-      ),
-      z.array(spanSchema)
-    );
-  }
-  /**
-   * Get aggregate performance stats (count, p50/p95/p99 latency, failure rate)
-   * grouped by transaction name + op, most frequent first, with offset-based
-   * pagination — same shape as the other list endpoints.
-   */
-  async getStats(projectId, options) {
-    const searchParams = {};
-    if (options?.page) {
-      searchParams.page = String(options.page);
-    }
-    if (options?.per_page) {
-      searchParams.per_page = String(options.per_page);
-    }
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/transactions/stats`, {
-        searchParams
-      }),
-      offsetPaginatedResponseSchema(transactionStatsSchema)
-    );
-  }
-  /**
-   * Get aggregate stats for a single (transaction name, op) group — a direct
-   * lookup that works regardless of how many groups the project has. Reports
-   * `not_found` when the group has no transactions.
-   */
-  async getStatForGroup(projectId, name, op) {
-    const searchParams = { name };
-    if (op) {
-      searchParams.op = op;
-    }
-    return this.request(
-      () => this.http.get(`api/projects/${projectId}/transactions/stats/group`, {
-        searchParams
-      }),
-      transactionStatsSchema
-    );
-  }
-  /**
-   * Get a single transaction by ID with its full Sentry payload (spans,
-   * contexts.trace, measurements, tags) for the performance detail view.
-   */
-  async get(projectId, transactionId) {
-    return this.request(
-      () => this.http.get(
-        `api/projects/${projectId}/transactions/${transactionId}`
-      ),
-      transactionDetailSchema
-    );
-  }
-};
-
-// src/client.ts
-var RustrakClient = class {
-  http;
-  /**
-   * Authentication API resource
-   */
-  auth;
-  /**
-   * Projects API resource
-   */
-  projects;
-  /**
-   * Issues API resource
-   */
-  issues;
-  /**
-   * Events API resource
-   */
-  events;
-  /**
-   * Auth Tokens API resource
-   */
-  tokens;
-  /**
-   * Alert Integrations API resource (global credential destinations)
-   */
-  alertIntegrations;
-  /**
-   * Alert Rules API resource (per-project alert configuration)
-   */
-  alertRules;
-  /**
-   * Source Maps API resource (sentry-cli artifact bundle upload protocol)
-   */
-  sourceMaps;
-  /**
-   * Team API resource (global user roster and roles)
-   */
-  team;
-  /**
-   * Invitations API resource (pending user invitations)
-   */
-  invitations;
-  /**
-   * Project Members API resource (per-project membership and roles)
-   */
-  members;
-  /**
-   * Sessions API resource (release health)
-   */
-  sessions;
-  /**
-   * Releases API resource (data scoped to a specific release)
-   */
-  releases;
-  /**
-   * Transactions API resource (performance monitoring)
-   */
-  transactions;
-  /**
-   * Logs API resource (standalone logs)
-   */
-  logs;
-  /**
-   * Cron monitors API resource (Sentry Crons)
-   */
-  monitors;
-  /**
-   * Schedules API resource (previews for crontab/interval schedules)
-   */
-  schedules;
-  /**
-   * Spans API resource (standalone + transaction-embedded spans, shared table)
-   */
-  spans;
-  /**
-   * AI Agent Monitoring dashboard API resource
-   */
-  agents;
-  /**
-   * Stats API resource (project-wide overview aggregates)
-   */
-  stats;
-  /**
-   * Storage API resource (usage + retention cleanup, admin only)
-   */
-  storage;
-  /**
-   * Health API resource (version info)
-   */
-  health;
-  /**
-   * GitHub integration resource
-   */
-  github;
-  /**
-   * Create a new Rustrak API client
-   *
-   * @param config - Client configuration
-   */
-  constructor(config) {
-    this.http = createKyInstance(config);
-    this.auth = new AuthResource(this.http);
-    this.projects = new ProjectsResource(this.http);
-    this.issues = new IssuesResource(this.http);
-    this.events = new EventsResource(this.http);
-    this.tokens = new TokensResource(this.http);
-    this.github = new GitHubResource(this.http);
-    this.alertIntegrations = new AlertIntegrationsResource(this.http);
-    this.alertRules = new AlertRulesResource(this.http);
-    this.sourceMaps = new SourceMapsResource(this.http);
-    this.team = new TeamResource(this.http);
-    this.invitations = new InvitationsResource(this.http);
-    this.members = new MembersResource(this.http);
-    this.sessions = new SessionsResource(this.http);
-    this.releases = new ReleasesResource(this.http);
-    this.transactions = new TransactionsResource(this.http);
-    this.logs = new LogsResource(this.http);
-    this.monitors = new MonitorsResource(this.http);
-    this.schedules = new SchedulesResource(this.http);
-    this.spans = new SpansResource(this.http);
-    this.agents = new AgentsResource(this.http);
-    this.stats = new StatsResource(this.http);
-    this.storage = new StorageResource(this.http);
-    this.health = new HealthResource(this.http);
-  }
-};
-
-export { Err, FIELD_ERROR_CODES, NETWORK_ERROR_MESSAGE, Ok, RustrakClient, SERVER_ERROR_MESSAGE, TIMEOUT_ERROR_MESSAGE, isRetryable, mapResult, unwrap, unwrapOr };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map