@sentry/api 0.444.0 → 0.446.0

package/dist/api-client/endpoints/index.js

@@ -0,0 +1,762 @@
+// src/api-client/endpoints/client-keys.ts
+import {
+  apiPath,
+  validateResponse
+} from "@sentry/api/client";
+async function listClientKeys({ core, origin }, { organizationSlug, projectSlug }, schema) {
+  const body = await core.requestJson(origin, apiPath`/projects/${organizationSlug}/${projectSlug}/keys/`);
+  return validateResponse(schema, body);
+}
+async function createClientKey({ core, origin }, {
+  organizationSlug,
+  projectSlug,
+  name
+}, schema) {
+  const body = await core.requestJson(origin, apiPath`/projects/${organizationSlug}/${projectSlug}/keys/`, { method: "POST", body: JSON.stringify({ name }) });
+  return validateResponse(schema, body);
+}
+async function updateClientKey({ core, origin }, {
+  organizationSlug,
+  projectSlug,
+  keyId,
+  name,
+  isActive,
+  rateLimit,
+  browserSdkVersion,
+  dynamicSdkLoaderOptions
+}, schema) {
+  const data = {};
+  if (name !== undefined) {
+    data.name = name;
+  }
+  if (isActive !== undefined) {
+    data.isActive = isActive;
+  }
+  if (rateLimit !== undefined) {
+    data.rateLimit = rateLimit;
+  }
+  if (browserSdkVersion !== undefined) {
+    data.browserSdkVersion = browserSdkVersion;
+  }
+  if (dynamicSdkLoaderOptions !== undefined) {
+    data.dynamicSdkLoaderOptions = dynamicSdkLoaderOptions;
+  }
+  const body = await core.requestJson(origin, apiPath`/projects/${organizationSlug}/${projectSlug}/keys/${keyId}/`, { method: "PUT", body: JSON.stringify(data) });
+  return validateResponse(schema, body);
+}
+// src/api-client/endpoints/dashboards.ts
+import {
+  apiPath as apiPath2,
+  nextPageCursor,
+  readJsonResponse,
+  validateResponse as validateResponse2
+} from "@sentry/api/client";
+async function listDashboards({ core, origin }, { organizationSlug, query, sortBy, limit = 10, cursor }, schema) {
+  const params = new URLSearchParams;
+  params.set("per_page", String(limit));
+  if (query) {
+    params.set("query", query);
+  }
+  if (sortBy) {
+    params.set("sort", sortBy);
+  }
+  if (cursor) {
+    params.set("cursor", cursor);
+  }
+  const response = await core.request(origin, `${apiPath2`/organizations/${organizationSlug}/dashboards/`}?${params.toString()}`);
+  return {
+    items: validateResponse2(schema, await readJsonResponse(response)),
+    nextCursor: nextPageCursor(response)
+  };
+}
+async function getDashboard({ core, origin }, { organizationSlug, dashboardId }, schema) {
+  const body = await core.requestJson(origin, apiPath2`/organizations/${organizationSlug}/dashboards/${dashboardId}/`);
+  return validateResponse2(schema, body);
+}
+// src/api-client/endpoints/monitors.ts
+import {
+  apiPath as apiPath3,
+  applyStatsMixinTimeParams,
+  applyTimeParams,
+  defaultStatsPeriod,
+  parseStatsPeriod,
+  validateResponse as validateResponse3,
+  withQuery
+} from "@sentry/api/client";
+async function listMonitors({ core, origin }, {
+  organizationSlug,
+  projectSlug,
+  environment,
+  owner,
+  query,
+  limit
+}, schema) {
+  const params = new URLSearchParams;
+  if (projectSlug) {
+    params.append("projectSlug", projectSlug);
+  }
+  if (environment) {
+    params.append("environment", environment);
+  }
+  if (owner) {
+    params.append("owner", owner);
+  }
+  if (query) {
+    params.set("query", query);
+  }
+  if (limit !== undefined) {
+    params.set("per_page", String(limit));
+  }
+  const body = await core.requestJson(origin, withQuery(apiPath3`/organizations/${organizationSlug}/monitors/`, params));
+  return validateResponse3(schema, body);
+}
+function monitorPath({ organizationSlug, projectSlug, monitorSlug }, suffix = "") {
+  const path = projectSlug ? apiPath3`/projects/${organizationSlug}/${projectSlug}/monitors/${monitorSlug}/` : apiPath3`/organizations/${organizationSlug}/monitors/${monitorSlug}/`;
+  return `${path}${suffix}`;
+}
+function environmentQuery(environment) {
+  const params = new URLSearchParams;
+  if (environment) {
+    params.append("environment", environment);
+  }
+  return params;
+}
+async function getMonitor({ core, origin }, params, schema) {
+  const body = await core.requestJson(origin, withQuery(monitorPath(params), environmentQuery(params.environment)));
+  return validateResponse3(schema, body);
+}
+async function deleteMonitorEnvironment({ core, origin }, {
+  organizationSlug,
+  projectSlug,
+  monitorSlug,
+  environment
+}) {
+  await core.request(origin, apiPath3`/projects/${organizationSlug}/${projectSlug}/monitors/${monitorSlug}/environments/${environment}/`, { method: "DELETE" }, { allowStatuses: [404] });
+}
+async function listMonitorCheckIns({ core, origin }, params, schema) {
+  const query = environmentQuery(params.environment);
+  if (params.limit !== undefined) {
+    query.set("per_page", String(params.limit));
+  }
+  const statsPeriod = defaultStatsPeriod(params);
+  if (statsPeriod) {
+    parseStatsPeriod(statsPeriod);
+  }
+  applyTimeParams(query, statsPeriod, params.start, params.end);
+  const body = await core.requestJson(origin, withQuery(monitorPath(params, "checkins/"), query));
+  return validateResponse3(schema, body);
+}
+async function getMonitorStats({ core, origin }, params, schema) {
+  const query = environmentQuery(params.environment);
+  applyStatsMixinTimeParams(query, defaultStatsPeriod(params), params.start, params.end, params.rollup);
+  const body = await core.requestJson(origin, withQuery(monitorPath(params, "stats/"), query));
+  return validateResponse3(schema, body);
+}
+// src/api-client/endpoints/organizations.ts
+import { listOrganizations as listOrganizationsOperation } from "@sentry/api";
+import {
+  apiPath as apiPath4,
+  listPage,
+  validateResponse as validateResponse4,
+  withQuery as withQuery2
+} from "@sentry/api/client";
+async function getAuthenticatedUser({ core, origin }, schema) {
+  return validateResponse4(schema, await core.requestJson(origin, "/auth/"));
+}
+async function listOrganizations({ core, origin }, params, schema) {
+  const client = core.sdkClient(origin, "/organizations/");
+  return await listPage((perPage, cursor) => listOrganizationsOperation({
+    client,
+    query: { per_page: perPage, query: params.query, cursor },
+    throwOnError: true
+  }), schema, params.limit ?? 25, params.cursor);
+}
+async function getOrganization({ core, origin }, params, schema) {
+  const query = new URLSearchParams;
+  if (params.includeFeatureFlags) {
+    query.set("include_feature_flags", "1");
+  }
+  if (params.detailed === false) {
+    query.set("detailed", "0");
+  }
+  const body = await core.requestJson(origin, withQuery2(apiPath4`/organizations/${params.organizationSlug}/`, query));
+  return validateResponse4(schema, body);
+}
+async function updateAgenticOnboardingStatus({ core, origin }, { organizationSlug, update }, schema) {
+  const body = await core.requestJson(origin, apiPath4`/organizations/${organizationSlug}/onboarding/agent/status/`, { method: "POST", body: JSON.stringify(update) });
+  return validateResponse4(schema, body);
+}
+// src/api-client/endpoints/profiling.ts
+import {
+  apiPath as apiPath5,
+  validateResponse as validateResponse5
+} from "@sentry/api/client";
+async function getFlamegraph({ core, origin }, {
+  organizationSlug,
+  projectId,
+  transactionName,
+  statsPeriod = "7d"
+}, schema) {
+  const query = new URLSearchParams;
+  query.set("project", projectId.toString());
+  const escapedTransaction = transactionName.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+  query.set("query", `event.type:transaction transaction:"${escapedTransaction}"`);
+  query.set("statsPeriod", statsPeriod);
+  const body = await core.requestJson(origin, apiPath5`/organizations/${organizationSlug}/profiling/flamegraph/` + `?${query.toString()}`);
+  return validateResponse5(schema, body);
+}
+async function getTransactionProfile({ core, origin }, {
+  organizationSlug,
+  projectSlugOrId,
+  profileId
+}, schema) {
+  const body = await core.requestJson(origin, apiPath5`/projects/${organizationSlug}/${projectSlugOrId}/profiling/profiles/${profileId}/`);
+  return validateResponse5(schema, body);
+}
+async function getProfileChunks({ core, origin }, {
+  organizationSlug,
+  profilerId,
+  projectId,
+  start,
+  end
+}, schema) {
+  const query = new URLSearchParams;
+  query.set("profiler_id", profilerId);
+  query.set("project", projectId.toString());
+  query.set("start", start);
+  query.set("end", end);
+  const body = await core.requestJson(origin, apiPath5`/organizations/${organizationSlug}/profiling/chunks/` + `?${query.toString()}`);
+  return validateResponse5(schema, body);
+}
+// src/api-client/endpoints/projects.ts
+import { listOrganizationProjects } from "@sentry/api";
+import {
+  apiPath as apiPath6,
+  fetchAllPages,
+  listPage as listPage2,
+  MAX_LIST_PAGES,
+  nextPageCursor as nextPageCursor2,
+  readJsonResponse as readJsonResponse2,
+  validateResponse as validateResponse6,
+  withQuery as withQuery3
+} from "@sentry/api/client";
+async function listProjects({ core, origin }, params, schema) {
+  const client = core.sdkClient(origin, apiPath6`/organizations/${params.organizationSlug}/projects/`);
+  return await listPage2((perPage, cursor) => listOrganizationProjects({
+    client,
+    path: { organization_id_or_slug: params.organizationSlug },
+    query: { per_page: perPage, query: params.query, cursor },
+    throwOnError: true
+  }), schema, params.limit ?? 25, params.cursor);
+}
+async function getProject({ core, origin }, { organizationSlug, projectSlugOrId, collapse }, schema) {
+  const query = new URLSearchParams;
+  if (collapse) {
+    query.set("collapse", collapse);
+  }
+  const body = await core.requestJson(origin, withQuery3(apiPath6`/projects/${organizationSlug}/${projectSlugOrId}/`, query));
+  return validateResponse6(schema, body);
+}
+async function createProject({ core, origin }, { organizationSlug, teamSlug, name, slug, platform }, schema) {
+  const data = { name };
+  if (slug) {
+    data.slug = slug;
+  }
+  if (platform) {
+    data.platform = platform;
+  }
+  const body = await core.requestJson(origin, apiPath6`/teams/${organizationSlug}/${teamSlug}/projects/`, { method: "POST", body: JSON.stringify(data) });
+  return validateResponse6(schema, body);
+}
+async function updateProject({ core, origin }, { organizationSlug, projectSlug, name, slug, platform }, schema) {
+  const data = {};
+  if (name)
+    data.name = name;
+  if (slug)
+    data.slug = slug;
+  if (platform)
+    data.platform = platform;
+  const body = await core.requestJson(origin, apiPath6`/projects/${organizationSlug}/${projectSlug}/`, { method: "PUT", body: JSON.stringify(data) });
+  return validateResponse6(schema, body);
+}
+async function listProjectTeams({ core, origin }, { organizationSlug, projectSlug }, schema) {
+  const result = await fetchAllPages(async (cursor) => {
+    const query = new URLSearchParams;
+    query.set("per_page", "100");
+    if (cursor) {
+      query.set("cursor", cursor);
+    }
+    const response = await core.request(origin, `${apiPath6`/projects/${organizationSlug}/${projectSlug}/teams/`}?${query.toString()}`);
+    return {
+      data: await readJsonResponse2(response),
+      nextCursor: nextPageCursor2(response) ?? undefined
+    };
+  }, (data) => validateResponse6(schema, data), MAX_LIST_PAGES);
+  if (!result.ok) {
+    throw new Error(result.reason === "page-cap" ? "API pagination exceeded its page limit" : "API returned a repeated pagination cursor");
+  }
+  return result.items;
+}
+async function addProjectTeam({ core, origin }, {
+  organizationSlug,
+  projectSlug,
+  teamSlug
+}) {
+  await core.request(origin, apiPath6`/projects/${organizationSlug}/${projectSlug}/teams/${teamSlug}/`, { method: "POST", body: JSON.stringify({}) });
+}
+async function removeProjectTeam({ core, origin }, {
+  organizationSlug,
+  projectSlug,
+  teamSlug
+}) {
+  await core.request(origin, apiPath6`/projects/${organizationSlug}/${projectSlug}/teams/${teamSlug}/`, { method: "DELETE" });
+}
+// src/api-client/endpoints/releases.ts
+import {
+  apiPath as apiPath7,
+  validateResponse as validateResponse7,
+  withQuery as withQuery4
+} from "@sentry/api/client";
+async function listReleases({ core, origin }, { organizationSlug, projectSlug, query, limit }, schema) {
+  const params = new URLSearchParams;
+  if (query) {
+    params.set("query", query);
+  }
+  if (limit !== undefined) {
+    params.set("per_page", String(limit));
+  }
+  const path = projectSlug ? apiPath7`/projects/${organizationSlug}/${projectSlug}/releases/` : apiPath7`/organizations/${organizationSlug}/releases/`;
+  const body = await core.requestJson(origin, withQuery4(path, params));
+  return validateResponse7(schema, body);
+}
+async function getRelease({ core, origin }, {
+  organizationSlug,
+  releaseVersion,
+  projectSlugOrId,
+  includeHealth
+}, schema) {
+  const params = new URLSearchParams;
+  if (includeHealth) {
+    params.set("health", "1");
+  }
+  const path = projectSlugOrId ? apiPath7`/projects/${organizationSlug}/${projectSlugOrId}/releases/${releaseVersion}/` : apiPath7`/organizations/${organizationSlug}/releases/${releaseVersion}/`;
+  const body = await core.requestJson(origin, withQuery4(path, params));
+  return validateResponse7(schema, body);
+}
+async function listReleaseDeploys({ core, origin }, {
+  organizationSlug,
+  releaseVersion,
+  projectSlugOrId,
+  limit
+}, schema) {
+  const params = new URLSearchParams;
+  if (projectSlugOrId) {
+    params.set(/^\d+$/.test(projectSlugOrId) ? "project" : "projectSlug", projectSlugOrId);
+  }
+  if (limit !== undefined) {
+    params.set("per_page", String(limit));
+  }
+  const path = apiPath7`/organizations/${organizationSlug}/releases/${releaseVersion}/deploys/`;
+  const body = await core.requestJson(origin, withQuery4(path, params));
+  return validateResponse7(schema, body);
+}
+async function listReleaseCommits({ core, origin }, {
+  organizationSlug,
+  releaseVersion,
+  projectSlugOrId,
+  limit
+}, schema) {
+  const params = new URLSearchParams;
+  if (limit !== undefined) {
+    params.set("per_page", String(limit));
+  }
+  const path = projectSlugOrId ? apiPath7`/projects/${organizationSlug}/${projectSlugOrId}/releases/${releaseVersion}/commits/` : apiPath7`/organizations/${organizationSlug}/releases/${releaseVersion}/commits/`;
+  const body = await core.requestJson(origin, withQuery4(path, params));
+  return validateResponse7(schema, body);
+}
+async function getEventCommitters({ core, origin }, { organizationSlug, projectSlug, eventId }, schema) {
+  const body = await core.requestJson(origin, apiPath7`/projects/${organizationSlug}/${projectSlug}/events/${eventId}/committers/`);
+  return validateResponse7(schema, body);
+}
+// src/api-client/endpoints/replays.ts
+import {
+  apiPath as apiPath8,
+  applyTimeParams as applyTimeParams2,
+  nextPageCursor as nextPageCursor3,
+  readJsonResponse as readJsonResponse3,
+  validateResponse as validateResponse8,
+  withQuery as withQuery5
+} from "@sentry/api/client";
+var REPLAY_SEGMENTS_PER_PAGE = 100;
+async function searchReplays({ core, origin }, {
+  organizationSlug,
+  query,
+  limit,
+  projectId,
+  sort,
+  environment,
+  statsPeriod,
+  start,
+  end,
+  fields
+}, schema) {
+  const params = new URLSearchParams;
+  if (query) {
+    params.set("query", query);
+  }
+  if (limit !== undefined) {
+    params.set("per_page", String(limit));
+  }
+  if (projectId) {
+    params.append("project", projectId);
+  }
+  if (sort) {
+    params.set("sort", sort);
+  }
+  if (environment) {
+    const environments = Array.isArray(environment) ? environment : [environment];
+    for (const value of environments) {
+      params.append("environment", value);
+    }
+  }
+  for (const field of fields ?? []) {
+    params.append("field", field);
+  }
+  applyTimeParams2(params, statsPeriod, start, end);
+  const body = await core.requestJson(origin, withQuery5(apiPath8`/organizations/${organizationSlug}/replays/`, params));
+  return validateResponse8(schema, body);
+}
+async function getReplay({ core, origin }, {
+  organizationSlug,
+  replayId
+}, schema) {
+  const body = await core.requestJson(origin, apiPath8`/organizations/${organizationSlug}/replays/${replayId}/`);
+  return validateResponse8(schema, body);
+}
+async function listIssueReplayIds({ core, origin }, { organizationSlug, issueId, dataSource }, schema) {
+  const params = new URLSearchParams;
+  params.set("returnIds", "true");
+  params.set("query", `issue.id:[${String(issueId)}]`);
+  params.set("data_source", dataSource);
+  params.set("statsPeriod", "90d");
+  params.append("project", "-1");
+  const body = await core.requestJson(origin, apiPath8`/organizations/${organizationSlug}/replay-count/` + `?${params.toString()}`);
+  return validateResponse8(schema, body);
+}
+async function visitReplayRecordingSegments({ core, origin }, {
+  organizationSlug,
+  projectSlugOrId,
+  replayId,
+  maxSegments
+}, pageSchema, onSegment) {
+  let cursor = null;
+  let segmentsRead = 0;
+  do {
+    const params = new URLSearchParams;
+    params.set("per_page", String(REPLAY_SEGMENTS_PER_PAGE));
+    if (cursor) {
+      params.set("cursor", cursor);
+    }
+    const response = await core.request(origin, apiPath8`/projects/${organizationSlug}/${projectSlugOrId}/replays/${replayId}/recording-segments/` + `?${params.toString()}`, { method: "GET" });
+    const page = validateResponse8(pageSchema, await readJsonResponse3(response));
+    for (const segment of page) {
+      if (segmentsRead >= maxSegments) {
+        return { segmentsRead, truncated: true };
+      }
+      onSegment(segment);
+      segmentsRead += 1;
+    }
+    cursor = nextPageCursor3(response);
+    if (cursor && (segmentsRead >= maxSegments || page.length === 0)) {
+      return { segmentsRead, truncated: true };
+    }
+  } while (cursor);
+  return { segmentsRead, truncated: false };
+}
+// src/api-client/endpoints/repositories.ts
+import {
+  apiPath as apiPath9,
+  fetchAllPages as fetchAllPages2,
+  MAX_LIST_PAGES as MAX_LIST_PAGES2,
+  nextPageCursor as nextPageCursor4,
+  readJsonResponse as readJsonResponse4,
+  validateResponse as validateResponse9
+} from "@sentry/api/client";
+async function listRepositories({ core, origin }, { organizationSlug, query }, schema) {
+  const result = await fetchAllPages2(async (cursor) => {
+    const params = new URLSearchParams;
+    params.set("per_page", "100");
+    if (query) {
+      params.set("query", query);
+    }
+    if (cursor) {
+      params.set("cursor", cursor);
+    }
+    const response = await core.request(origin, `${apiPath9`/organizations/${organizationSlug}/repos/`}?${params.toString()}`, { method: "GET" });
+    return {
+      data: await readJsonResponse4(response),
+      nextCursor: nextPageCursor4(response) ?? undefined
+    };
+  }, (data) => validateResponse9(schema, data), MAX_LIST_PAGES2);
+  if (!result.ok) {
+    throw new Error(result.reason === "page-cap" ? "API pagination exceeded its page limit" : "API returned a repeated pagination cursor");
+  }
+  return result.items;
+}
+async function linkProjectRepository({ core, origin }, {
+  organizationSlug,
+  projectSlug,
+  repository,
+  provider
+}, schema) {
+  const body = await core.requestJson(origin, apiPath9`/organizations/${organizationSlug}/code-mappings/bulk/`, {
+    method: "POST",
+    body: JSON.stringify({
+      project: projectSlug,
+      repository,
+      provider,
+      mappings: [{ stackRoot: "", sourceRoot: "" }]
+    })
+  });
+  return validateResponse9(schema, body);
+}
+// src/api-client/endpoints/snapshots.ts
+import { apiPath as apiPath10, withQuery as withQuery6 } from "@sentry/api/client";
+async function getSnapshot({ core, origin }, {
+  organizationSlug,
+  snapshotId,
+  compactMetadata = true
+}) {
+  const query = new URLSearchParams;
+  if (compactMetadata) {
+    query.set("compact_metadata", "true");
+  }
+  return await core.requestJson(origin, withQuery6(apiPath10`/organizations/${organizationSlug}/preprodartifacts/snapshots/${snapshotId}/`, query));
+}
+async function getSnapshotImage({ core, origin }, {
+  organizationSlug,
+  snapshotId,
+  imageIdentifier
+}) {
+  return await core.requestJson(origin, apiPath10`/organizations/${organizationSlug}/preprodartifacts/snapshots/${snapshotId}/images/${imageIdentifier}/`);
+}
+async function getLatestBaseSnapshot({ core, origin }, {
+  organizationSlug,
+  appId,
+  branch,
+  project,
+  projectSlug,
+  compactMetadata = true
+}) {
+  const query = new URLSearchParams;
+  query.set("app_id", appId);
+  if (branch)
+    query.set("branch", branch);
+  if (project)
+    query.set("project", project);
+  if (projectSlug)
+    query.set("projectSlug", projectSlug);
+  if (compactMetadata)
+    query.set("compact_metadata", "true");
+  return await core.requestJson(origin, apiPath10`/organizations/${organizationSlug}/preprodartifacts/snapshots/latest-base/` + `?${query.toString()}`);
+}
+// src/api-client/endpoints/teams.ts
+import { listOrganizationTeams } from "@sentry/api";
+import {
+  apiPath as apiPath11,
+  listPage as listPage3,
+  validateResponse as validateResponse10
+} from "@sentry/api/client";
+async function listTeams({ core, origin }, params, schema) {
+  const client = core.sdkClient(origin, apiPath11`/organizations/${params.organizationSlug}/teams/`);
+  return await listPage3((perPage, cursor) => listOrganizationTeams({
+    client,
+    path: { organization_id_or_slug: params.organizationSlug },
+    query: { per_page: perPage, query: params.query, cursor },
+    throwOnError: true
+  }), schema, params.limit ?? 25, params.cursor);
+}
+async function createTeam({ core, origin }, { organizationSlug, name }, schema) {
+  const body = await core.requestJson(origin, apiPath11`/organizations/${organizationSlug}/teams/`, { method: "POST", body: JSON.stringify({ name }) });
+  return validateResponse10(schema, body);
+}
+// src/api-client/endpoints/traces.ts
+import {
+  apiPath as apiPath12,
+  validateResponse as validateResponse11
+} from "@sentry/api/client";
+async function getTraceMeta({ core, origin }, { organizationSlug, traceId, statsPeriod = "14d" }, schema) {
+  const query = new URLSearchParams({ statsPeriod });
+  const body = await core.requestJson(origin, apiPath12`/organizations/${organizationSlug}/trace-meta/${traceId}/` + `?${query.toString()}`);
+  return validateResponse11(schema, body);
+}
+async function getTrace({ core, origin }, {
+  organizationSlug,
+  traceId,
+  limit = 1000,
+  project = "-1",
+  statsPeriod = "14d"
+}, schema) {
+  const query = new URLSearchParams;
+  query.set("limit", String(limit));
+  query.set("project", project);
+  query.set("statsPeriod", statsPeriod);
+  const body = await core.requestJson(origin, apiPath12`/organizations/${organizationSlug}/trace/${traceId}/` + `?${query.toString()}`);
+  return validateResponse11(schema, body);
+}
+// src/api-client/endpoints/uptime-monitors.ts
+import {
+  apiPath as apiPath13,
+  applyTimeParams as applyTimeParams3,
+  defaultStatsPeriod as defaultStatsPeriod2,
+  parseStatsPeriod as parseStatsPeriod2,
+  validateResponse as validateResponse12,
+  withQuery as withQuery7
+} from "@sentry/api/client";
+async function listUptimeMonitors({ core, origin }, {
+  organizationSlug,
+  projectId,
+  environment,
+  owner,
+  query,
+  limit
+}, schema) {
+  const params = new URLSearchParams;
+  if (projectId) {
+    params.append("project", projectId);
+  }
+  if (environment) {
+    params.append("environment", environment);
+  }
+  if (owner) {
+    params.append("owner", owner);
+  }
+  if (query) {
+    params.set("query", query);
+  }
+  if (limit !== undefined) {
+    params.set("per_page", String(limit));
+  }
+  const body = await core.requestJson(origin, withQuery7(apiPath13`/organizations/${organizationSlug}/uptime/`, params));
+  return validateResponse12(schema, body);
+}
+function uptimeMonitorPath({
+  organizationSlug,
+  projectSlug,
+  uptimeMonitorId
+}) {
+  return apiPath13`/projects/${organizationSlug}/${projectSlug}/uptime/${uptimeMonitorId}/`;
+}
+async function getUptimeMonitor({ core, origin }, params, schema) {
+  const body = await core.requestJson(origin, uptimeMonitorPath(params));
+  return validateResponse12(schema, body);
+}
+async function listUptimeMonitorChecks({ core, origin }, params, schema) {
+  const query = new URLSearchParams;
+  if (params.limit !== undefined) {
+    query.set("per_page", String(params.limit));
+  }
+  const statsPeriod = defaultStatsPeriod2(params);
+  if (statsPeriod) {
+    parseStatsPeriod2(statsPeriod);
+  }
+  applyTimeParams3(query, statsPeriod, params.start, params.end);
+  const body = await core.requestJson(origin, withQuery7(`${uptimeMonitorPath(params)}checks/`, query));
+  return validateResponse12(schema, body);
+}
+var UPTIME_MONITOR_FIELDS = [
+  "name",
+  "url",
+  "intervalSeconds",
+  "timeoutMs",
+  "method",
+  "headers",
+  "body",
+  "assertion",
+  "status",
+  "owner",
+  "environment",
+  "traceSampling",
+  "responseCaptureEnabled",
+  "recoveryThreshold",
+  "downtimeThreshold"
+];
+function uptimeMonitorBody(fields) {
+  const payload = {};
+  for (const field of UPTIME_MONITOR_FIELDS) {
+    if (fields[field] !== undefined) {
+      payload[field] = fields[field];
+    }
+  }
+  return JSON.stringify(payload);
+}
+async function createUptimeMonitor({ core, origin }, {
+  organizationSlug,
+  projectSlug,
+  ...fields
+}, schema) {
+  const body = await core.requestJson(origin, apiPath13`/projects/${organizationSlug}/${projectSlug}/uptime/`, { method: "POST", body: uptimeMonitorBody(fields) });
+  return validateResponse12(schema, body);
+}
+async function updateUptimeMonitor({ core, origin }, {
+  organizationSlug,
+  projectSlug,
+  uptimeMonitorId,
+  ...fields
+}, schema) {
+  const body = await core.requestJson(origin, uptimeMonitorPath({ organizationSlug, projectSlug, uptimeMonitorId }), { method: "PUT", body: uptimeMonitorBody(fields) });
+  return validateResponse12(schema, body);
+}
+async function deleteUptimeMonitor({ core, origin }, params) {
+  await core.request(origin, uptimeMonitorPath(params), { method: "DELETE" }, { allowStatuses: [404] });
+}
+export {
+  visitReplayRecordingSegments,
+  updateUptimeMonitor,
+  updateProject,
+  updateClientKey,
+  updateAgenticOnboardingStatus,
+  searchReplays,
+  removeProjectTeam,
+  listUptimeMonitors,
+  listUptimeMonitorChecks,
+  listTeams,
+  listRepositories,
+  listReleases,
+  listReleaseDeploys,
+  listReleaseCommits,
+  listProjects,
+  listProjectTeams,
+  listOrganizations,
+  listMonitors,
+  listMonitorCheckIns,
+  listIssueReplayIds,
+  listDashboards,
+  listClientKeys,
+  linkProjectRepository,
+  getUptimeMonitor,
+  getTransactionProfile,
+  getTraceMeta,
+  getTrace,
+  getSnapshotImage,
+  getSnapshot,
+  getReplay,
+  getRelease,
+  getProject,
+  getProfileChunks,
+  getOrganization,
+  getMonitorStats,
+  getMonitor,
+  getLatestBaseSnapshot,
+  getFlamegraph,
+  getEventCommitters,
+  getDashboard,
+  getAuthenticatedUser,
+  deleteUptimeMonitor,
+  deleteMonitorEnvironment,
+  createUptimeMonitor,
+  createTeam,
+  createProject,
+  createClientKey,
+  addProjectTeam
+};