@keystrokehq/sentry 0.0.1

package/dist/teams.mjs

@@ -0,0 +1,266 @@
+import { orgScopeInputSchema, orgTeamScopeInputSchema, sentryIdSchema, sentryJsonObjectSchema, sentryListInputSchema, sentryMemberSchema, sentryProjectSummarySchema, sentrySlugSchema, sentryTeamSchema } from "./schemas.mjs";
+import { t as defineSentryEndpoint } from "./endpoint-factory-BwjbcPwW.mjs";
+import { t as SENTRY_SCOPE } from "./scopes-RRU0vt-a.mjs";
+import { z } from "zod";
+
+//#region src/teams.ts
+/**
+* Sentry team operations. Maps to PLAN.md §6.3 (14 actions).
+*/
+const ORG = [{
+	name: "organization_slug",
+	placeholder: "{organization_slug}"
+}];
+const ORG_TEAM = [...ORG, {
+	name: "team_slug",
+	placeholder: "{team_slug}"
+}];
+const ORG_TEAM_MEMBER = [...ORG_TEAM, {
+	name: "member_id",
+	placeholder: "{member_id}"
+}];
+const listTeamsInOrganization = defineSentryEndpoint({
+	id: "list_teams_in_organization",
+	name: "List Teams In Organization",
+	description: "List the teams in an organization with pagination.",
+	method: "GET",
+	path: "/api/0/organizations/{organization_slug}/teams/",
+	pathParams: ORG,
+	input: sentryListInputSchema.merge(orgScopeInputSchema).extend({ detailed: z.string().optional() }),
+	queryFields: [
+		"query",
+		"cursor",
+		"per_page",
+		"detailed"
+	],
+	output: z.array(sentryTeamSchema),
+	pagination: "cursor",
+	requiredOAuthScopes: [...SENTRY_SCOPE.teamRead]
+});
+const listOrganizationUserTeams = defineSentryEndpoint({
+	id: "list_organization_user_teams",
+	name: "List Teams For Current User",
+	description: "List the teams the authenticated user belongs to in this organization.",
+	method: "GET",
+	path: "/api/0/organizations/{organization_slug}/user-teams/",
+	pathParams: ORG,
+	input: orgScopeInputSchema,
+	output: z.array(sentryTeamSchema),
+	requiredOAuthScopes: [...SENTRY_SCOPE.teamRead]
+});
+const createOrganizationTeam = defineSentryEndpoint({
+	id: "create_organization_team",
+	name: "Create Organization Team",
+	description: "Create a new team inside the organization.",
+	method: "POST",
+	path: "/api/0/organizations/{organization_slug}/teams/",
+	pathParams: ORG,
+	input: orgScopeInputSchema.extend({
+		slug: sentrySlugSchema.optional(),
+		name: z.string().min(1).optional(),
+		idp_provisioned: z.boolean().optional()
+	}),
+	bodyFields: [
+		"slug",
+		"name",
+		"idp_provisioned"
+	],
+	output: sentryTeamSchema,
+	needsApproval: true,
+	requiredOAuthScopes: [...SENTRY_SCOPE.teamWrite]
+});
+const retrieveTeamInfoViaOrganizationIdOrSlug = defineSentryEndpoint({
+	id: "retrieve_team_info_via_organization_id_or_slug",
+	name: "Retrieve Team Info",
+	description: "Fetch a single team by its slug.",
+	method: "GET",
+	path: "/api/0/teams/{organization_slug}/{team_slug}/",
+	pathParams: ORG_TEAM,
+	input: orgTeamScopeInputSchema,
+	output: sentryTeamSchema,
+	requiredOAuthScopes: [...SENTRY_SCOPE.teamRead]
+});
+const updateTeamInformationByOrganizationId = defineSentryEndpoint({
+	id: "update_team_information_by_organization_id",
+	name: "Update Team",
+	description: "Update a team’s slug or display name.",
+	method: "PUT",
+	path: "/api/0/teams/{organization_slug}/{team_slug}/",
+	pathParams: ORG_TEAM,
+	input: orgTeamScopeInputSchema.extend({
+		slug: sentrySlugSchema.optional(),
+		name: z.string().min(1).optional()
+	}),
+	bodyFields: ["slug", "name"],
+	output: sentryTeamSchema,
+	needsApproval: true,
+	requiredOAuthScopes: [...SENTRY_SCOPE.teamWrite]
+});
+const deleteTeamByOrganizationOrTeamSlug = defineSentryEndpoint({
+	id: "delete_team_by_organization_or_team_slug",
+	name: "Delete Team",
+	description: "Delete a team by slug.",
+	method: "DELETE",
+	path: "/api/0/teams/{organization_slug}/{team_slug}/",
+	pathParams: ORG_TEAM,
+	input: orgTeamScopeInputSchema,
+	output: z.unknown(),
+	needsApproval: true,
+	requiredOAuthScopes: [...SENTRY_SCOPE.teamAdmin]
+});
+const addTeamMemberInOrganization = defineSentryEndpoint({
+	id: "add_team_member_in_organization",
+	name: "Add Team Member",
+	description: "Add a member to a team.",
+	method: "POST",
+	path: "/api/0/organizations/{organization_slug}/members/{member_id}/teams/{team_slug}/",
+	pathParams: ORG_TEAM_MEMBER,
+	input: orgTeamScopeInputSchema.extend({ member_id: sentryIdSchema }),
+	output: sentryMemberSchema,
+	needsApproval: true,
+	requiredOAuthScopes: [...SENTRY_SCOPE.teamWrite]
+});
+const getTeamMembersByIdOrSlug = defineSentryEndpoint({
+	id: "get_team_members_by_id_or_slug",
+	name: "Get Team Members",
+	description: "List the members of a team.",
+	method: "GET",
+	path: "/api/0/teams/{organization_slug}/{team_slug}/members/",
+	pathParams: ORG_TEAM,
+	input: sentryListInputSchema.merge(orgTeamScopeInputSchema),
+	queryFields: [
+		"cursor",
+		"per_page",
+		"query"
+	],
+	output: z.array(sentryMemberSchema),
+	pagination: "cursor",
+	requiredOAuthScopes: [...SENTRY_SCOPE.teamRead]
+});
+const deleteMemberFromTeam = defineSentryEndpoint({
+	id: "delete_member_from_team",
+	name: "Remove Member From Team",
+	description: "Remove a member from a team.",
+	method: "DELETE",
+	path: "/api/0/organizations/{organization_slug}/members/{member_id}/teams/{team_slug}/",
+	pathParams: ORG_TEAM_MEMBER,
+	input: orgTeamScopeInputSchema.extend({ member_id: sentryIdSchema }),
+	output: z.unknown(),
+	needsApproval: true,
+	requiredOAuthScopes: [...SENTRY_SCOPE.teamWrite]
+});
+const switchTeamRoleForMember = defineSentryEndpoint({
+	id: "switch_team_role_for_member",
+	name: "Switch Member Team Role",
+	description: "Update a member’s role within a team.",
+	method: "PUT",
+	path: "/api/0/organizations/{organization_slug}/members/{member_id}/teams/{team_slug}/",
+	pathParams: ORG_TEAM_MEMBER,
+	input: orgTeamScopeInputSchema.extend({
+		member_id: sentryIdSchema,
+		teamRole: z.string().nullable()
+	}),
+	bodyFields: ["teamRole"],
+	output: sentryMemberSchema,
+	needsApproval: true,
+	requiredOAuthScopes: [...SENTRY_SCOPE.teamWrite]
+});
+const retrieveTeamProjects = defineSentryEndpoint({
+	id: "retrieve_team_projects",
+	name: "Retrieve Team Projects",
+	description: "List the projects owned by a team.",
+	method: "GET",
+	path: "/api/0/teams/{organization_slug}/{team_slug}/projects/",
+	pathParams: ORG_TEAM,
+	input: sentryListInputSchema.merge(orgTeamScopeInputSchema),
+	queryFields: [
+		"cursor",
+		"per_page",
+		"query"
+	],
+	output: z.array(sentryProjectSummarySchema),
+	pagination: "cursor",
+	requiredOAuthScopes: [...SENTRY_SCOPE.projectRead]
+});
+const manageTeamExternalIntegrations = defineSentryEndpoint({
+	id: "manage_team_external_integrations",
+	name: "Manage Team External Integrations",
+	description: "Create an external-team link between a Sentry team and a third-party team (Slack, PagerDuty, etc.).",
+	method: "POST",
+	path: "/api/0/teams/{organization_slug}/{team_slug}/external-teams/",
+	pathParams: ORG_TEAM,
+	input: orgTeamScopeInputSchema.extend({
+		externalName: z.string().min(1),
+		provider: z.string().min(1),
+		externalId: z.string().optional(),
+		integrationId: z.string().optional()
+	}),
+	bodyFields: [
+		"externalName",
+		"provider",
+		"externalId",
+		"integrationId"
+	],
+	output: sentryJsonObjectSchema,
+	needsApproval: true,
+	requiredOAuthScopes: [...SENTRY_SCOPE.teamWrite]
+});
+const updateExternalTeamIntegration = defineSentryEndpoint({
+	id: "update_external_team_integration",
+	name: "Update External Team Integration",
+	description: "Update an existing external-team link by id.",
+	method: "PUT",
+	path: "/api/0/teams/{organization_slug}/{team_slug}/external-teams/{external_team_id}/",
+	pathParams: [...ORG_TEAM, {
+		name: "external_team_id",
+		placeholder: "{external_team_id}"
+	}],
+	input: orgTeamScopeInputSchema.extend({
+		external_team_id: sentryIdSchema,
+		externalName: z.string().min(1).optional(),
+		integrationId: z.string().optional(),
+		externalId: z.string().optional()
+	}),
+	bodyFields: [
+		"externalName",
+		"integrationId",
+		"externalId"
+	],
+	output: sentryJsonObjectSchema,
+	needsApproval: true,
+	requiredOAuthScopes: [...SENTRY_SCOPE.teamWrite]
+});
+const deleteExternalTeamById = defineSentryEndpoint({
+	id: "delete_external_team_by_id",
+	name: "Delete External Team",
+	description: "Remove an external-team link by id.",
+	method: "DELETE",
+	path: "/api/0/teams/{organization_slug}/{team_slug}/external-teams/{external_team_id}/",
+	pathParams: [...ORG_TEAM, {
+		name: "external_team_id",
+		placeholder: "{external_team_id}"
+	}],
+	input: orgTeamScopeInputSchema.extend({ external_team_id: sentryIdSchema }),
+	output: z.unknown(),
+	needsApproval: true,
+	requiredOAuthScopes: [...SENTRY_SCOPE.teamAdmin]
+});
+const sentryTeamOperations = {
+	listTeamsInOrganization,
+	listOrganizationUserTeams,
+	createOrganizationTeam,
+	retrieveTeamInfoViaOrganizationIdOrSlug,
+	updateTeamInformationByOrganizationId,
+	deleteTeamByOrganizationOrTeamSlug,
+	addTeamMemberInOrganization,
+	getTeamMembersByIdOrSlug,
+	deleteMemberFromTeam,
+	switchTeamRoleForMember,
+	retrieveTeamProjects,
+	manageTeamExternalIntegrations,
+	updateExternalTeamIntegration,
+	deleteExternalTeamById
+};
+
+//#endregion
+export { addTeamMemberInOrganization, createOrganizationTeam, deleteExternalTeamById, deleteMemberFromTeam, deleteTeamByOrganizationOrTeamSlug, getTeamMembersByIdOrSlug, listOrganizationUserTeams, listTeamsInOrganization, manageTeamExternalIntegrations, retrieveTeamInfoViaOrganizationIdOrSlug, retrieveTeamProjects, sentryTeamOperations, switchTeamRoleForMember, updateExternalTeamIntegration, updateTeamInformationByOrganizationId };

package/dist/triggers.d.mts

@@ -0,0 +1,83 @@
+import { n as sentry } from "./integration-C8KHkeNG.mjs";
+import { n as sentryAppCredentialSet } from "./provider-app-BANn4KOL.mjs";
+import { createSentryClient } from "./client.mjs";
+import { SentryDiscoverEventsPollResponse, sentryCommentCreatedEventSchema, sentryCommentDeletedEventSchema, sentryCommentUpdatedEventSchema, sentryErrorCreatedEventSchema, sentryEventAlertTriggeredEventSchema, sentryInstallationCreatedEventSchema, sentryInstallationDeletedEventSchema, sentryIssueArchivedEventSchema, sentryIssueAssignedEventSchema, sentryIssueCreatedEventSchema, sentryIssueIgnoredEventSchema, sentryIssueResolvedEventSchema, sentryIssueUnresolvedEventSchema, sentryMetricAlertCriticalEventSchema, sentryMetricAlertResolvedEventSchema, sentryMetricAlertWarningEventSchema, sentryPreprodArtifactBuildDistributionCompletedEventSchema, sentryPreprodArtifactSizeAnalysisCompletedEventSchema, sentrySeerCodingCompletedEventSchema, sentrySeerCodingStartedEventSchema, sentrySeerPrCreatedEventSchema, sentrySeerRootCauseCompletedEventSchema, sentrySeerRootCauseStartedEventSchema, sentrySeerSolutionCompletedEventSchema, sentrySeerSolutionStartedEventSchema, sentryServiceHookEventAlertSchema } from "./events.mjs";
+import { BoundTrigger, WebhookRequest } from "@keystrokehq/core";
+import { z } from "zod";
+import { IntegrationTriggerBindingFactory, IntegrationTriggerBindingOptions, createPollingTriggerBindingFactory } from "@keystrokehq/integration-authoring";
+import { PollingTriggerManifest, WebhookTriggerManifest } from "@keystrokehq/core/trigger";
+
+//#region src/triggers.d.ts
+type Schedule = Parameters<typeof createPollingTriggerBindingFactory>[0]['schedule'];
+type IntegrationWebhookCredentialSets = readonly [typeof sentry, typeof sentryAppCredentialSet];
+type ServiceHookCredentialSets = readonly [typeof sentry];
+type DiscoverPollingCredentialSets = readonly [typeof sentry];
+type SentryWebhookBinding<TPayload> = IntegrationTriggerBindingFactory<TPayload, IntegrationWebhookCredentialSets, WebhookTriggerManifest, TPayload, WebhookRequest>;
+type SentryServiceHookBinding = IntegrationTriggerBindingFactory<z.output<typeof sentryServiceHookEventAlertSchema>, ServiceHookCredentialSets, WebhookTriggerManifest, z.output<typeof sentryServiceHookEventAlertSchema>, WebhookRequest>;
+type SentryOnTriggerNamespace = Readonly<{
+  installationCreated: SentryWebhookBinding<z.output<typeof sentryInstallationCreatedEventSchema>>;
+  installationDeleted: SentryWebhookBinding<z.output<typeof sentryInstallationDeletedEventSchema>>;
+  issueCreated: SentryWebhookBinding<z.output<typeof sentryIssueCreatedEventSchema>>;
+  issueResolved: SentryWebhookBinding<z.output<typeof sentryIssueResolvedEventSchema>>;
+  issueAssigned: SentryWebhookBinding<z.output<typeof sentryIssueAssignedEventSchema>>;
+  issueUnresolved: SentryWebhookBinding<z.output<typeof sentryIssueUnresolvedEventSchema>>;
+  issueIgnored: SentryWebhookBinding<z.output<typeof sentryIssueIgnoredEventSchema>>;
+  issueArchived: SentryWebhookBinding<z.output<typeof sentryIssueArchivedEventSchema>>;
+  errorCreated: SentryWebhookBinding<z.output<typeof sentryErrorCreatedEventSchema>>;
+  commentCreated: SentryWebhookBinding<z.output<typeof sentryCommentCreatedEventSchema>>;
+  commentUpdated: SentryWebhookBinding<z.output<typeof sentryCommentUpdatedEventSchema>>;
+  commentDeleted: SentryWebhookBinding<z.output<typeof sentryCommentDeletedEventSchema>>;
+  eventAlertTriggered: SentryWebhookBinding<z.output<typeof sentryEventAlertTriggeredEventSchema>>;
+  metricAlertCritical: SentryWebhookBinding<z.output<typeof sentryMetricAlertCriticalEventSchema>>;
+  metricAlertWarning: SentryWebhookBinding<z.output<typeof sentryMetricAlertWarningEventSchema>>;
+  metricAlertResolved: SentryWebhookBinding<z.output<typeof sentryMetricAlertResolvedEventSchema>>;
+  seerRootCauseStarted: SentryWebhookBinding<z.output<typeof sentrySeerRootCauseStartedEventSchema>>;
+  seerRootCauseCompleted: SentryWebhookBinding<z.output<typeof sentrySeerRootCauseCompletedEventSchema>>;
+  seerSolutionStarted: SentryWebhookBinding<z.output<typeof sentrySeerSolutionStartedEventSchema>>;
+  seerSolutionCompleted: SentryWebhookBinding<z.output<typeof sentrySeerSolutionCompletedEventSchema>>;
+  seerCodingStarted: SentryWebhookBinding<z.output<typeof sentrySeerCodingStartedEventSchema>>;
+  seerCodingCompleted: SentryWebhookBinding<z.output<typeof sentrySeerCodingCompletedEventSchema>>;
+  seerPrCreated: SentryWebhookBinding<z.output<typeof sentrySeerPrCreatedEventSchema>>;
+  preprodSizeAnalysisCompleted: SentryWebhookBinding<z.output<typeof sentryPreprodArtifactSizeAnalysisCompletedEventSchema>>;
+  preprodBuildDistributionCompleted: SentryWebhookBinding<z.output<typeof sentryPreprodArtifactBuildDistributionCompletedEventSchema>>;
+}>;
+declare const on: SentryOnTriggerNamespace;
+type SentryWebhookTriggerNamespace = Readonly<{
+  serviceHookEventAlert: SentryServiceHookBinding;
+}>;
+declare const webhooks: SentryWebhookTriggerNamespace;
+interface DiscoverEventsPollParams {
+  readonly field: readonly string[];
+  readonly query?: string;
+  readonly project?: readonly number[];
+  readonly environment?: readonly string[];
+  readonly statsPeriod?: string;
+  readonly dataset?: 'discover' | 'errors' | 'transactions' | 'issuePlatform';
+  readonly per_page?: number;
+  /** Override the org slug stored on the credentials. */
+  readonly organization_slug?: string;
+}
+interface DiscoverBindingOptions<TOutput = SentryDiscoverEventsPollResponse> extends IntegrationTriggerBindingOptions<SentryDiscoverEventsPollResponse, TOutput> {
+  readonly schedule?: Schedule;
+}
+/**
+ * Pure helper that the polling `poll` callback delegates to. Exported so it
+ * can be unit-tested without standing up the full polling harness.
+ */
+declare function executeDiscoverEventsPoll(params: DiscoverEventsPollParams, credentials: {
+  readonly SENTRY_ACCESS_TOKEN: string;
+  readonly SENTRY_REGION_URL?: string;
+  readonly SENTRY_ORG_SLUG?: string;
+}, options?: {
+  readonly clientFactory?: typeof createSentryClient;
+}): Promise<SentryDiscoverEventsPollResponse>;
+declare function computeDiscoverEventsPollIdempotencyKey(response: SentryDiscoverEventsPollResponse): string | undefined;
+declare function bindDiscoverEventsPollingTrigger<TOutput = SentryDiscoverEventsPollResponse>(params: DiscoverEventsPollParams, options?: DiscoverBindingOptions<TOutput>): BoundTrigger<SentryDiscoverEventsPollResponse, DiscoverPollingCredentialSets, PollingTriggerManifest, TOutput>;
+declare const polling: Readonly<{
+  readonly discoverEvents: typeof bindDiscoverEventsPollingTrigger;
+}>;
+type SentryOnTriggers = typeof on;
+type SentryWebhookTriggers = typeof webhooks;
+type SentryPollingTriggers = typeof polling;
+//#endregion
+export { DiscoverEventsPollParams, SentryOnTriggers, SentryPollingTriggers, SentryWebhookTriggers, computeDiscoverEventsPollIdempotencyKey, executeDiscoverEventsPoll, on, polling, webhooks };

package/dist/triggers.mjs

@@ -0,0 +1,263 @@
+import { i as sentryAppCredentialSet, t as sentry } from "./integration-WwY95cWE.mjs";
+import { createSentryClient } from "./client.mjs";
+import { sentryCommentCreatedEventSchema, sentryCommentDeletedEventSchema, sentryCommentUpdatedEventSchema, sentryDiscoverEventsPollResponseSchema, sentryErrorCreatedEventSchema, sentryEventAlertTriggeredEventSchema, sentryInstallationCreatedEventSchema, sentryInstallationDeletedEventSchema, sentryIssueArchivedEventSchema, sentryIssueAssignedEventSchema, sentryIssueCreatedEventSchema, sentryIssueIgnoredEventSchema, sentryIssueResolvedEventSchema, sentryIssueUnresolvedEventSchema, sentryMetricAlertCriticalEventSchema, sentryMetricAlertResolvedEventSchema, sentryMetricAlertWarningEventSchema, sentryPreprodArtifactBuildDistributionCompletedEventSchema, sentryPreprodArtifactSizeAnalysisCompletedEventSchema, sentrySeerCodingCompletedEventSchema, sentrySeerCodingStartedEventSchema, sentrySeerPrCreatedEventSchema, sentrySeerRootCauseCompletedEventSchema, sentrySeerRootCauseStartedEventSchema, sentrySeerSolutionCompletedEventSchema, sentrySeerSolutionStartedEventSchema, sentryServiceHookEventAlertSchema } from "./events.mjs";
+import { createPollingTriggerBindingFactory, createWebhookTriggerBindingFactory } from "@keystrokehq/integration-authoring";
+
+//#region src/triggers.ts
+const INTEGRATION_WEBHOOK_PATH = "/sentry";
+const SERVICE_HOOK_PATH = "/sentry/service-hook";
+const integrationCredentialSets = [sentry, sentryAppCredentialSet];
+const serviceHookCredentialSets = [sentry];
+const discoverPollingCredentialSets = [sentry];
+function createIntegrationWebhookBinding(config) {
+	return createWebhookTriggerBindingFactory({
+		defaultName: config.defaultName,
+		defaultDescription: config.defaultDescription,
+		path: INTEGRATION_WEBHOOK_PATH,
+		method: "POST",
+		payload: config.payload,
+		credentialSets: integrationCredentialSets,
+		idempotencyKey: (payload) => config.idempotencyKey(payload)
+	});
+}
+const installationCreatedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Installation Created",
+	defaultDescription: "Fired when the Sentry app is installed on an organization.",
+	payload: sentryInstallationCreatedEventSchema,
+	idempotencyKey: (p) => `installation.created:${p.installation.uuid}`
+});
+const installationDeletedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Installation Deleted",
+	defaultDescription: "Fired when the Sentry app is uninstalled from an organization.",
+	payload: sentryInstallationDeletedEventSchema,
+	idempotencyKey: (p) => `installation.deleted:${p.installation.uuid}`
+});
+const issueCreatedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Issue Created",
+	defaultDescription: "Fired when a new Sentry issue is created.",
+	payload: sentryIssueCreatedEventSchema,
+	idempotencyKey: (p) => `issue.created:${p.data.issue.id}`
+});
+const issueResolvedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Issue Resolved",
+	defaultDescription: "Fired when a Sentry issue transitions to resolved.",
+	payload: sentryIssueResolvedEventSchema,
+	idempotencyKey: (p) => `issue.resolved:${p.data.issue.id}`
+});
+const issueAssignedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Issue Assigned",
+	defaultDescription: "Fired when a Sentry issue is assigned to a team or user.",
+	payload: sentryIssueAssignedEventSchema,
+	idempotencyKey: (p) => `issue.assigned:${p.data.issue.id}:${String(p.actor?.id ?? "anon")}`
+});
+const issueUnresolvedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Issue Unresolved",
+	defaultDescription: "Fired when a Sentry issue regresses or is re-opened.",
+	payload: sentryIssueUnresolvedEventSchema,
+	idempotencyKey: (p) => `issue.unresolved:${p.data.issue.id}`
+});
+const issueIgnoredBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Issue Ignored",
+	defaultDescription: "Fired when a Sentry issue is ignored/muted (legacy action; superseded by `archived`).",
+	payload: sentryIssueIgnoredEventSchema,
+	idempotencyKey: (p) => `issue.ignored:${p.data.issue.id}`
+});
+const issueArchivedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Issue Archived",
+	defaultDescription: "Fired when a Sentry issue is archived (new state model).",
+	payload: sentryIssueArchivedEventSchema,
+	idempotencyKey: (p) => `issue.archived:${p.data.issue.id}`
+});
+const errorCreatedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Error Created",
+	defaultDescription: "Fired for every new error event delivered when the integration subscribes to the `error` resource. This is high volume — always pair with a filter.",
+	payload: sentryErrorCreatedEventSchema,
+	idempotencyKey: (p) => `error.created:${p.data.error.event_id ?? "unknown"}`
+});
+const commentCreatedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Comment Created",
+	defaultDescription: "Fired when a new comment is posted on a Sentry issue.",
+	payload: sentryCommentCreatedEventSchema,
+	idempotencyKey: (p) => `comment.created:${String(p.data.comment_id ?? "unknown")}:${String(p.data.timestamp ?? "")}`
+});
+const commentUpdatedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Comment Updated",
+	defaultDescription: "Fired when a Sentry issue comment is edited.",
+	payload: sentryCommentUpdatedEventSchema,
+	idempotencyKey: (p) => `comment.updated:${String(p.data.comment_id ?? "unknown")}:${String(p.data.timestamp ?? "")}`
+});
+const commentDeletedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Comment Deleted",
+	defaultDescription: "Fired when a Sentry issue comment is removed.",
+	payload: sentryCommentDeletedEventSchema,
+	idempotencyKey: (p) => `comment.deleted:${String(p.data.comment_id ?? "unknown")}`
+});
+const eventAlertTriggeredBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Event Alert Triggered",
+	defaultDescription: "Fired when a Sentry issue-alert-rule condition fires.",
+	payload: sentryEventAlertTriggeredEventSchema,
+	idempotencyKey: (p) => `event_alert.triggered:${String(p.data.triggered_rule ?? "rule")}:${String(p.data.issue_id ?? "no-issue")}`
+});
+const metricAlertCriticalBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Metric Alert Critical",
+	defaultDescription: "Fired when a Sentry metric alert crosses the critical threshold.",
+	payload: sentryMetricAlertCriticalEventSchema,
+	idempotencyKey: (p) => `metric_alert.critical:${String(p.data.metric_alert.id)}:${String(p.data.metric_alert.status ?? "")}`
+});
+const metricAlertWarningBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Metric Alert Warning",
+	defaultDescription: "Fired when a Sentry metric alert crosses the warning threshold.",
+	payload: sentryMetricAlertWarningEventSchema,
+	idempotencyKey: (p) => `metric_alert.warning:${String(p.data.metric_alert.id)}:${String(p.data.metric_alert.status ?? "")}`
+});
+const metricAlertResolvedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Metric Alert Resolved",
+	defaultDescription: "Fired when a Sentry metric alert returns to a healthy state.",
+	payload: sentryMetricAlertResolvedEventSchema,
+	idempotencyKey: (p) => `metric_alert.resolved:${String(p.data.metric_alert.id)}:${String(p.data.metric_alert.status ?? "")}`
+});
+const seerRootCauseStartedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Seer Root Cause Started",
+	defaultDescription: "Fired when Seer root-cause analysis begins.",
+	payload: sentrySeerRootCauseStartedEventSchema,
+	idempotencyKey: (p) => `seer.root_cause_started:${p.data.run_id}`
+});
+const seerRootCauseCompletedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Seer Root Cause Completed",
+	defaultDescription: "Fired when Seer root-cause analysis completes.",
+	payload: sentrySeerRootCauseCompletedEventSchema,
+	idempotencyKey: (p) => `seer.root_cause_completed:${p.data.run_id}`
+});
+const seerSolutionStartedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Seer Solution Started",
+	defaultDescription: "Fired when Seer solution generation begins.",
+	payload: sentrySeerSolutionStartedEventSchema,
+	idempotencyKey: (p) => `seer.solution_started:${p.data.run_id}`
+});
+const seerSolutionCompletedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Seer Solution Completed",
+	defaultDescription: "Fired when Seer has generated a solution.",
+	payload: sentrySeerSolutionCompletedEventSchema,
+	idempotencyKey: (p) => `seer.solution_completed:${p.data.run_id}`
+});
+const seerCodingStartedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Seer Coding Started",
+	defaultDescription: "Fired when the Seer coding step begins.",
+	payload: sentrySeerCodingStartedEventSchema,
+	idempotencyKey: (p) => `seer.coding_started:${p.data.run_id}`
+});
+const seerCodingCompletedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Seer Coding Completed",
+	defaultDescription: "Fired when Seer code changes are ready.",
+	payload: sentrySeerCodingCompletedEventSchema,
+	idempotencyKey: (p) => `seer.coding_completed:${p.data.run_id}`
+});
+const seerPrCreatedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Seer PR Created",
+	defaultDescription: "Fired when Seer opens a pull request with the fix.",
+	payload: sentrySeerPrCreatedEventSchema,
+	idempotencyKey: (p) => `seer.pr_created:${p.data.run_id}`
+});
+const preprodSizeAnalysisCompletedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Preprod Size Analysis Completed",
+	defaultDescription: "Fired when mobile-build size analysis completes or fails.",
+	payload: sentryPreprodArtifactSizeAnalysisCompletedEventSchema,
+	idempotencyKey: (p) => `preprod_artifact.size_analysis_completed:${p.data.buildId}`
+});
+const preprodBuildDistributionCompletedBind = createIntegrationWebhookBinding({
+	defaultName: "Sentry Preprod Build Distribution Completed",
+	defaultDescription: "Fired when build-distribution processing completes or fails for a mobile artifact.",
+	payload: sentryPreprodArtifactBuildDistributionCompletedEventSchema,
+	idempotencyKey: (p) => `preprod_artifact.build_distribution_completed:${p.data.buildId}`
+});
+const serviceHookEventAlertBind = createWebhookTriggerBindingFactory({
+	defaultName: "Sentry Project Service Hook",
+	defaultDescription: "Legacy per-project service-hook delivery. Signed with a per-hook secret.",
+	path: SERVICE_HOOK_PATH,
+	method: "POST",
+	payload: sentryServiceHookEventAlertSchema,
+	credentialSets: serviceHookCredentialSets,
+	idempotencyKey: (payload) => payload.event_id != null ? `service_hook.event.alert:${payload.event_id}` : void 0
+});
+const on = Object.freeze({
+	installationCreated: installationCreatedBind,
+	installationDeleted: installationDeletedBind,
+	issueCreated: issueCreatedBind,
+	issueResolved: issueResolvedBind,
+	issueAssigned: issueAssignedBind,
+	issueUnresolved: issueUnresolvedBind,
+	issueIgnored: issueIgnoredBind,
+	issueArchived: issueArchivedBind,
+	errorCreated: errorCreatedBind,
+	commentCreated: commentCreatedBind,
+	commentUpdated: commentUpdatedBind,
+	commentDeleted: commentDeletedBind,
+	eventAlertTriggered: eventAlertTriggeredBind,
+	metricAlertCritical: metricAlertCriticalBind,
+	metricAlertWarning: metricAlertWarningBind,
+	metricAlertResolved: metricAlertResolvedBind,
+	seerRootCauseStarted: seerRootCauseStartedBind,
+	seerRootCauseCompleted: seerRootCauseCompletedBind,
+	seerSolutionStarted: seerSolutionStartedBind,
+	seerSolutionCompleted: seerSolutionCompletedBind,
+	seerCodingStarted: seerCodingStartedBind,
+	seerCodingCompleted: seerCodingCompletedBind,
+	seerPrCreated: seerPrCreatedBind,
+	preprodSizeAnalysisCompleted: preprodSizeAnalysisCompletedBind,
+	preprodBuildDistributionCompleted: preprodBuildDistributionCompletedBind
+});
+const webhooks = Object.freeze({ serviceHookEventAlert: serviceHookEventAlertBind });
+function withDefaultSchedule(schedule) {
+	if (schedule === void 0) return "5m";
+	return schedule;
+}
+/**
+* Pure helper that the polling `poll` callback delegates to. Exported so it
+* can be unit-tested without standing up the full polling harness.
+*/
+async function executeDiscoverEventsPoll(params, credentials, options) {
+	const clientCreds = {
+		SENTRY_ACCESS_TOKEN: credentials.SENTRY_ACCESS_TOKEN,
+		...credentials.SENTRY_REGION_URL ? { SENTRY_REGION_URL: credentials.SENTRY_REGION_URL } : {},
+		...credentials.SENTRY_ORG_SLUG ? { SENTRY_ORG_SLUG: credentials.SENTRY_ORG_SLUG } : {}
+	};
+	const orgSlug = params.organization_slug ?? credentials.SENTRY_ORG_SLUG;
+	if (!orgSlug) throw new Error("Sentry Discover polling trigger requires an organization slug — supply `params.organization_slug` or store `SENTRY_ORG_SLUG` on the credentials.");
+	const client = (options?.clientFactory ?? createSentryClient)(clientCreds);
+	const query = { field: [...params.field] };
+	if (params.query != null) query.query = params.query;
+	if (params.project) query.project = [...params.project];
+	if (params.environment) query.environment = [...params.environment];
+	if (params.statsPeriod) query.statsPeriod = params.statsPeriod;
+	if (params.dataset) query.dataset = params.dataset;
+	if (params.per_page != null) query.per_page = params.per_page;
+	return (await client.get(`/api/0/organizations/${encodeURIComponent(orgSlug)}/events/`, query)).data;
+}
+function computeDiscoverEventsPollIdempotencyKey(response) {
+	const first = response.data[0];
+	if (!first) return void 0;
+	const asRecord = first;
+	const id = asRecord.event_id ?? asRecord.id;
+	if (typeof id === "string" && id.length > 0) return `discover:${id}`;
+	if (typeof id === "number") return `discover:${id}`;
+}
+function bindDiscoverEventsPollingTrigger(params, options) {
+	return createPollingTriggerBindingFactory({
+		defaultName: "Sentry Discover Events Poll",
+		defaultDescription: "Poll the Sentry Discover events endpoint on a schedule and emit new rows as triggers.",
+		schedule: withDefaultSchedule(options?.schedule),
+		credentialSets: discoverPollingCredentialSets,
+		response: sentryDiscoverEventsPollResponseSchema,
+		poll: async (ctx) => executeDiscoverEventsPoll(params, ctx.credentials.sentry),
+		idempotencyKey: (response) => computeDiscoverEventsPollIdempotencyKey(response)
+	})({
+		...options?.name ? { name: options.name } : {},
+		...options?.description ? { description: options.description } : {},
+		...options?.filter ? { filter: options.filter } : {},
+		...options?.transform ? { transform: options.transform } : {}
+	});
+}
+const polling = Object.freeze({ discoverEvents: bindDiscoverEventsPollingTrigger });
+
+//#endregion
+export { computeDiscoverEventsPollIdempotencyKey, executeDiscoverEventsPoll, on, polling, webhooks };