@rustrak/client 0.16.4 → 0.18.0

package/README.md

@@ -1,9 +1,9 @@
 <div align="center">
-  <a href="https://rustrak.github.io/rustrak">
+  <a href="https://rustrak.dev">
     <img src="https://raw.githubusercontent.com/rustrak/rustrak/main/apps/docs/public/logo.svg" alt="Rustrak" width="64" height="64" />
   </a>
   <h1>@rustrak/client</h1>
-  <p>Official TypeScript client for the <a href="https://rustrak.github.io/rustrak">Rustrak</a> self-hosted error tracking API</p>
+  <p>Official TypeScript client for the <a href="https://rustrak.dev">Rustrak</a> self-hosted error tracking API</p>
 
   <p>
     <a href="https://www.npmjs.com/package/@rustrak/client">
@@ -24,7 +24,7 @@
   </p>
 
   <p>
-    <a href="https://rustrak.github.io/rustrak/sdks/client">Documentation</a>
+    <a href="https://rustrak.dev/sdks/client">Documentation</a>
     ·
     <a href="https://github.com/rustrak/rustrak">GitHub</a>
     ·
@@ -34,7 +34,7 @@
 
 ---
 
-`@rustrak/client` is the official TypeScript client for [Rustrak](https://rustrak.github.io/rustrak) — an ultra-lightweight, self-hosted error tracking system compatible with any Sentry SDK. This package wraps the Rustrak REST API with full type safety, runtime validation via Zod, built-in retry logic, and structured error handling. Total bundle size: ~28 KB.
+`@rustrak/client` is the official TypeScript client for [Rustrak](https://rustrak.dev) — an ultra-lightweight, self-hosted error tracking system compatible with any Sentry SDK. This package wraps the Rustrak REST API with full type safety, runtime validation via Zod, built-in retry logic, and structured error handling. Total bundle size: ~28 KB.
 
 ## Installation
 
@@ -78,7 +78,7 @@ const resolved = await client.issues.updateState(1, 'issue-id', {
 });
 ```
 
-**[Full documentation →](https://rustrak.github.io/rustrak/sdks/client)**
+**[Full documentation →](https://rustrak.dev/sdks/client)**
 
 ## Features
 
@@ -319,11 +319,11 @@ import type {
 
 ## What is Rustrak?
 
-[Rustrak](https://rustrak.github.io/rustrak) is a self-hosted error tracking server written in Rust that accepts events from any Sentry SDK: point the SDK's DSN at it and nothing else changes. One container serves the API and the dashboard.
+[Rustrak](https://rustrak.dev) is a self-hosted error tracking server written in Rust that accepts events from any Sentry SDK: point the SDK's DSN at it and nothing else changes. One container serves the API and the dashboard.
 
-- [Getting Started](https://rustrak.github.io/rustrak/getting-started/overview)
-- [Self-Hosting Guide](https://rustrak.github.io/rustrak/configuration/production)
-- [API Reference](https://rustrak.github.io/rustrak/api-reference)
+- [Getting Started](https://rustrak.dev/getting-started/overview)
+- [Self-Hosting Guide](https://rustrak.dev/configuration/production)
+- [API Reference](https://rustrak.dev/api-reference)
 - [GitHub](https://github.com/rustrak/rustrak)
 
 ## License

package/dist/index.cjs

@@ -134,13 +134,24 @@ var alertRuleChannelInputSchema = zod.z.object({
   integration_id: zod.z.number().int(),
   routing_override: zod.z.record(zod.z.string(), zod.z.unknown()).default({})
 });
+var alertRuleConditionsSchema = zod.z.object({
+  /** The quietest level that still fires. The server takes `null` as absent. */
+  min_level: zod.z.enum(["debug", "info", "warning", "error", "fatal"]).nullish(),
+  /** When non-empty, the only environments that fire. */
+  environments: zod.z.array(zod.z.string()).optional(),
+  /** A new issue fires when it reaches this many events, not on its first. */
+  min_events: zod.z.number().int().min(1).nullish()
+});
 var alertRuleSchema = zod.z.object({
   id: zod.z.number().int(),
   project_id: zod.z.number().int(),
   name: zod.z.string(),
   alert_type: alertTypeSchema,
   is_enabled: zod.z.boolean(),
-  conditions: zod.z.record(zod.z.string(), zod.z.unknown()),
+  // 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: zod.z.number().int(),
   last_triggered_at: dateTimeSchema.nullable(),
   created_at: dateTimeSchema,
@@ -153,13 +164,13 @@ var createAlertRuleSchema = zod.z.object({
   alert_type: alertTypeSchema,
   channels: zod.z.array(alertRuleChannelInputSchema).default([]),
   is_enabled: zod.z.boolean().optional(),
-  conditions: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  conditions: alertRuleConditionsSchema.optional(),
   cooldown_minutes: zod.z.number().int().min(0).optional()
 });
 var updateAlertRuleSchema = zod.z.object({
   name: zod.z.string().min(1).optional(),
   is_enabled: zod.z.boolean().optional(),
-  conditions: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  conditions: alertRuleConditionsSchema.optional(),
   cooldown_minutes: zod.z.number().int().min(0).optional(),
   channels: zod.z.array(alertRuleChannelInputSchema).optional()
 });
@@ -231,6 +242,89 @@ var eventDetailSchema = zod.z.object({
   data: zod.z.record(zod.z.string(), zod.z.any())
   // Full Sentry event JSON
 });
+var gitHubAppSchema = zod.z.object({
+  app_id: zod.z.number().int(),
+  slug: zod.z.string(),
+  html_url: zod.z.string(),
+  owner_login: zod.z.string(),
+  install_url: zod.z.string(),
+  last_webhook_at: dateTimeSchema.nullable(),
+  created_at: dateTimeSchema
+});
+var gitHubInstallationSchema = zod.z.object({
+  id: zod.z.number().int(),
+  account_login: zod.z.string(),
+  account_type: zod.z.string(),
+  suspended: zod.z.boolean(),
+  created_at: dateTimeSchema
+});
+var gitHubStatusSchema = zod.z.object({
+  app: gitHubAppSchema.nullable(),
+  installations: zod.z.array(gitHubInstallationSchema),
+  webhook_url: zod.z.string()
+});
+var gitHubManifestSchema = zod.z.object({
+  action_url: zod.z.string(),
+  manifest: zod.z.string()
+});
+var gitHubRepositorySchema = zod.z.object({
+  installation_id: zod.z.number().int(),
+  full_name: zod.z.string(),
+  default_branch: zod.z.string(),
+  private: zod.z.boolean(),
+  html_url: zod.z.string()
+});
+var codeMappingSchema = zod.z.object({
+  stack_root: zod.z.string(),
+  source_root: zod.z.string()
+});
+var projectRepositorySchema = zod.z.object({
+  project_id: zod.z.number().int(),
+  installation_id: zod.z.number().int(),
+  repo_full_name: zod.z.string(),
+  default_branch: zod.z.string(),
+  html_url: zod.z.string(),
+  code_mappings: zod.z.array(codeMappingSchema),
+  /** Open a GitHub issue for new issues that pass `auto_create_conditions`. */
+  auto_create_issues: zod.z.boolean(),
+  auto_create_conditions: alertRuleConditionsSchema,
+  codeowners_rules: zod.z.number().int().nullable(),
+  codeowners_synced_at: dateTimeSchema.nullable()
+});
+var updateProjectRepositorySchema = zod.z.object({
+  installation_id: zod.z.number().int(),
+  repo_full_name: zod.z.string().min(1),
+  code_mappings: zod.z.array(codeMappingSchema).optional(),
+  auto_create_issues: zod.z.boolean().optional(),
+  auto_create_conditions: alertRuleConditionsSchema.optional()
+});
+var issueLinkSchema = zod.z.object({
+  id: zod.z.number().int(),
+  issue_id: zod.z.string(),
+  repo_full_name: zod.z.string(),
+  number: zod.z.number().int(),
+  title: zod.z.string(),
+  url: zod.z.string(),
+  state: zod.z.string(),
+  created_at: dateTimeSchema
+});
+var repoCommitSchema = zod.z.object({
+  repo_full_name: zod.z.string(),
+  sha: zod.z.string(),
+  message: zod.z.string(),
+  author_name: zod.z.string(),
+  author_login: zod.z.string().nullable(),
+  url: zod.z.string(),
+  committed_at: dateTimeSchema
+});
+var issueGitHubSchema = zod.z.object({
+  links: zod.z.array(issueLinkSchema),
+  suspect_commits: zod.z.array(repoCommitSchema),
+  owners: zod.z.array(zod.z.string())
+});
+var gitHubLoginSchema = zod.z.object({
+  login: zod.z.string().nullable()
+});
 var globalRoleSchema = zod.z.enum(["admin", "member"]);
 var teamMemberSchema = zod.z.object({
   id: zod.z.number().int(),
@@ -414,6 +508,96 @@ var upsertProjectMemberSchema = zod.z.object({
   user_id: zod.z.number().int(),
   role: projectRoleSchema
 });
+var intervalUnitSchema = zod.z.enum([
+  "minute",
+  "hour",
+  "day",
+  "week",
+  "month",
+  "year"
+]);
+var scheduleSchema = zod.z.discriminatedUnion("type", [
+  zod.z.object({ type: zod.z.literal("crontab"), value: zod.z.string() }),
+  zod.z.object({
+    type: zod.z.literal("interval"),
+    value: zod.z.number().int().min(1),
+    unit: intervalUnitSchema
+  })
+]);
+var previewScheduleSchema = zod.z.object({
+  schedule: scheduleSchema,
+  /** IANA zone the schedule is read in. Defaults to UTC. */
+  timezone: zod.z.string().optional()
+});
+var schedulePreviewSchema = zod.z.object({
+  next_runs: zod.z.array(dateTimeSchema)
+});
+
+// src/schemas/monitor.ts
+var monitorConfigSchema = zod.z.object({
+  schedule: scheduleSchema,
+  checkin_margin: zod.z.number().int(),
+  max_runtime: zod.z.number().int(),
+  timezone: zod.z.string(),
+  failure_issue_threshold: zod.z.number().int(),
+  recovery_threshold: zod.z.number().int()
+});
+var monitorConfigInputSchema = zod.z.object({
+  schedule: scheduleSchema.optional(),
+  checkin_margin: zod.z.number().int().min(1).optional(),
+  max_runtime: zod.z.number().int().min(1).optional(),
+  timezone: zod.z.string().optional(),
+  failure_issue_threshold: zod.z.number().int().min(1).max(720).optional(),
+  recovery_threshold: zod.z.number().int().min(1).max(720).optional()
+});
+var checkInStatusSchema = zod.z.enum([
+  "ok",
+  "error",
+  "in_progress",
+  "missed",
+  "timeout",
+  "unknown"
+]);
+var monitorEnvironmentStatusSchema = zod.z.enum(["active", "ok", "error"]);
+var checkInSchema = zod.z.object({
+  id: uuidSchema,
+  environment: zod.z.string(),
+  status: checkInStatusSchema,
+  duration_ms: zod.z.number().int().nullable(),
+  date_added: dateTimeSchema,
+  date_updated: dateTimeSchema,
+  expected_time: dateTimeSchema.nullable()
+});
+var monitorEnvironmentSchema = zod.z.object({
+  id: uuidSchema,
+  environment: zod.z.string(),
+  status: monitorEnvironmentStatusSchema,
+  next_checkin: dateTimeSchema.nullable(),
+  next_checkin_latest: dateTimeSchema.nullable(),
+  last_checkin: dateTimeSchema.nullable(),
+  /** Newest first. */
+  recent_checkins: zod.z.array(checkInSchema)
+});
+var monitorSchema = zod.z.object({
+  id: uuidSchema,
+  slug: zod.z.string(),
+  name: zod.z.string(),
+  config: monitorConfigSchema,
+  is_muted: zod.z.boolean(),
+  created_at: dateTimeSchema,
+  environments: zod.z.array(monitorEnvironmentSchema)
+});
+var createMonitorSchema = zod.z.object({
+  name: zod.z.string().trim().min(1).max(128),
+  /** Derived from `name` when left out. */
+  slug: zod.z.string().min(1).max(50).optional(),
+  config: monitorConfigInputSchema
+});
+var updateMonitorSchema = zod.z.object({
+  name: zod.z.string().trim().min(1).max(128).optional(),
+  config: monitorConfigInputSchema.optional(),
+  is_muted: zod.z.boolean().optional()
+});
 var metricDeltaSchema = zod.z.object({
   current: zod.z.number().int(),
   /**
@@ -586,14 +770,21 @@ var projectStorageSchema = zod.z.object({
   spans_count: zod.z.number(),
   logs_count: zod.z.number(),
   source_maps_count: zod.z.number(),
-  estimated_bytes: zod.z.number()
+  /** `events_bytes + transactions_bytes + logs_bytes`. */
+  estimated_bytes: zod.z.number(),
+  events_bytes: zod.z.number(),
+  /** Transactions with their spans. */
+  transactions_bytes: zod.z.number(),
+  logs_bytes: zod.z.number()
 });
 var cleanupCountsSchema = zod.z.object({
   events: zod.z.number(),
   transactions: zod.z.number(),
   spans: zod.z.number(),
   logs: zod.z.number(),
-  issues_removed: zod.z.number()
+  issues_removed: zod.z.number(),
+  /** Unused source maps deleted; only a retention cleanup removes them. */
+  source_maps: zod.z.number().default(0)
 });
 var cleanupStatusSchema = zod.z.object({
   state: zod.z.enum(["idle", "running", "completed", "failed"]),
@@ -606,6 +797,53 @@ var sourceMapGcResultSchema = zod.z.object({
   files_removed: zod.z.number(),
   bytes_freed: zod.z.number()
 });
+var kindAgeSchema = zod.z.object({
+  counts: zod.z.array(zod.z.number()),
+  oldest: dateTimeSchema.nullable()
+});
+var storageAgeSchema = zod.z.object({
+  bucket_days: zod.z.array(zod.z.number()),
+  projects: zod.z.array(
+    zod.z.object({
+      project_id: zod.z.number(),
+      events: kindAgeSchema,
+      transactions: kindAgeSchema,
+      logs: kindAgeSchema
+    })
+  )
+});
+var retentionDaysSchema = zod.z.number().int().min(1).max(36500).nullable();
+var retentionWindowsSchema = zod.z.object({
+  events_days: retentionDaysSchema,
+  /** Transactions with their spans. */
+  transactions_days: retentionDaysSchema,
+  logs_days: retentionDaysSchema
+});
+var projectRetentionSchema = retentionWindowsSchema.extend({
+  project_id: zod.z.number().int()
+});
+var retentionSettingsSchema = zod.z.object({
+  defaults: retentionWindowsSchema,
+  overrides: zod.z.array(projectRetentionSchema),
+  frequency: zod.z.enum(["daily", "weekly"]),
+  /** Hour of the day, UTC. */
+  hour: zod.z.number().int().min(0).max(23),
+  /** Day of a weekly cleanup, 0 = Sunday. */
+  weekday: zod.z.number().int().min(0).max(6)
+});
+var retentionRunSchema = zod.z.object({
+  started_at: dateTimeSchema,
+  finished_at: dateTimeSchema.nullable(),
+  status: zod.z.enum(["running", "ok", "error"]),
+  removed: cleanupCountsSchema.nullable(),
+  error: zod.z.string().nullable()
+});
+var retentionSchema = zod.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 = zod.z.object({
   older_than_days: zod.z.number().int().min(1),
   project_id: zod.z.number().int().optional(),
@@ -1663,6 +1901,109 @@ var EventsResource = class extends BaseResource {
     );
   }
 };
+
+// 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 = zod.z.object({
   version: zod.z.string()
 });
@@ -2009,6 +2350,77 @@ var MembersResource = class extends BaseResource {
     );
   }
 };
+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`),
+      zod.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 {
@@ -2110,6 +2522,21 @@ var ReleasesResource = class extends BaseResource {
   }
 };
 
+// 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 {
   /**
@@ -2442,6 +2869,66 @@ var StorageResource = class extends BaseResource {
       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
@@ -2681,6 +3168,14 @@ var RustrakClient = class {
    * 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)
    */
@@ -2701,6 +3196,10 @@ var RustrakClient = class {
    * Health API resource (version info)
    */
   health;
+  /**
+   * GitHub integration resource
+   */
+  github;
   /**
    * Create a new Rustrak API client
    *
@@ -2713,6 +3212,7 @@ var RustrakClient = class {
     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);
@@ -2723,6 +3223,8 @@ var RustrakClient = class {
     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);