samva 0.15.0 → 0.17.0

package/dist/webhooks-CPXuu8Xf.js

@@ -0,0 +1,530 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { n as SensitiveString } from "./runtime-P0l1_2-C.js";
+import { D as Cursor, E as CreateWebhookPayload, Et as NamespaceId, Ht as SuccessResponse, Jt as UnauthorizedError, K as ForbiddenError, Lt as ResourceNotFoundError, Nt as PaymentRequiredError, Pt as RateLimitedError, Qt as UpdateWebhookPayload, Y as InternalError, ct as MailboxId, en as ValidationError, et as JsonValue, l as BillingProviderError, m as ConflictError, q as GatewayTimeoutError, qt as TestWebhookPayload, s as ApiKeySecurityMiddleware, tn as WebhookEndpointId } from "./client-DOzUrdTE.js";
+import { n as forGroup } from "./operation-n_IYgNVK.js";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/webhooks.ts
+const WebhookDeliveryCounts = /* @__PURE__ */ Schema.Struct({
+	total: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	pending: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	delivered: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	exhausted: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	cancelled: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" }))
+}).annotate({ identifier: "WebhookDeliveryCounts" });
+const WebhookDeliveryId = /* @__PURE__ */ Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^whdel_[0-9a-hjkmnp-tv-z]{16,24}$", "u")).annotate({
+	expected: "a string matching the RegExp ^whdel_[0-9a-hjkmnp-tv-z]{16,24}$",
+	identifier: "WebhookDeliveryId"
+})).pipe(Schema.brand("WebhookDeliveryId"));
+const WebhookAttemptId = /* @__PURE__ */ Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^whatt_[0-9a-hjkmnp-tv-z]{16,24}$", "u")).annotate({
+	expected: "a string matching the RegExp ^whatt_[0-9a-hjkmnp-tv-z]{16,24}$",
+	identifier: "WebhookAttemptId"
+})).pipe(Schema.brand("WebhookAttemptId"));
+const WebhookEventId = /* @__PURE__ */ Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^whevt_[0-9a-hjkmnp-tv-z]{16,24}$", "u")).annotate({
+	expected: "a string matching the RegExp ^whevt_[0-9a-hjkmnp-tv-z]{16,24}$",
+	identifier: "WebhookEventId"
+})).pipe(Schema.brand("WebhookEventId"));
+const WebhookDailyDeliveries = /* @__PURE__ */ Schema.Struct({
+	date: Schema.String,
+	pending: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	delivered: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	exhausted: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	cancelled: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" }))
+}).annotate({ identifier: "WebhookDailyDeliveries" });
+const WebhookEndpoint = /* @__PURE__ */ Schema.Struct({
+	id: WebhookEndpointId,
+	name: Schema.String,
+	url: Schema.String,
+	eventTypes: Schema.Array(Schema.Union([
+		Schema.Literal("message.sent"),
+		Schema.Literal("message.delivered"),
+		Schema.Literal("message.read"),
+		Schema.Literal("message.failed"),
+		Schema.Literal("message.bounced"),
+		Schema.Literal("message.complained"),
+		Schema.Literal("message.received"),
+		Schema.Literal("message.opened"),
+		Schema.Literal("message.clicked"),
+		Schema.Literal("contact.created"),
+		Schema.Literal("contact.updated"),
+		Schema.Literal("contact.deleted"),
+		Schema.Literal("contact.subscribed"),
+		Schema.Literal("contact.unsubscribed"),
+		Schema.Literal("contact.resubscribed"),
+		Schema.Literal("conversation.created"),
+		Schema.Literal("conversation.updated"),
+		Schema.Literal("conversation.archived"),
+		Schema.Literal("webhook.created"),
+		Schema.Literal("webhook.updated"),
+		Schema.Literal("webhook.deleted"),
+		Schema.Literal("webhook.test"),
+		Schema.Literal("domain.updated"),
+		Schema.Literal("domain.warming.updated"),
+		Schema.Literal("mailbox.message.received"),
+		Schema.Literal("mailbox.message.sent"),
+		Schema.Literal("mailbox.action.pending_approval"),
+		Schema.Literal("mailbox.message.quarantined"),
+		Schema.Literal("mailbox.message.released"),
+		Schema.Literal("mailbox.message.discarded"),
+		Schema.Literal("journey.webhook")
+	])),
+	channels: Schema.Union([Schema.Array(Schema.Literal("email")), Schema.Null]),
+	mailboxIds: Schema.Union([Schema.Array(MailboxId), Schema.Null]),
+	namespaceId: Schema.Union([NamespaceId, Schema.Null]),
+	status: Schema.Union([Schema.Literal("active"), Schema.Literal("disabled")]),
+	hasCustomHeaders: Schema.Boolean,
+	failureStartedAt: Schema.Union([Schema.String, Schema.Null]),
+	lastSucceededAt: Schema.Union([Schema.String, Schema.Null]),
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+}).annotate({ identifier: "WebhookEndpoint" });
+const WebhookEndpointListItem = /* @__PURE__ */ Schema.Struct({
+	id: WebhookEndpointId,
+	name: Schema.String,
+	url: Schema.String,
+	eventTypes: Schema.Array(Schema.Union([
+		Schema.Literal("message.sent"),
+		Schema.Literal("message.delivered"),
+		Schema.Literal("message.read"),
+		Schema.Literal("message.failed"),
+		Schema.Literal("message.bounced"),
+		Schema.Literal("message.complained"),
+		Schema.Literal("message.received"),
+		Schema.Literal("message.opened"),
+		Schema.Literal("message.clicked"),
+		Schema.Literal("contact.created"),
+		Schema.Literal("contact.updated"),
+		Schema.Literal("contact.deleted"),
+		Schema.Literal("contact.subscribed"),
+		Schema.Literal("contact.unsubscribed"),
+		Schema.Literal("contact.resubscribed"),
+		Schema.Literal("conversation.created"),
+		Schema.Literal("conversation.updated"),
+		Schema.Literal("conversation.archived"),
+		Schema.Literal("webhook.created"),
+		Schema.Literal("webhook.updated"),
+		Schema.Literal("webhook.deleted"),
+		Schema.Literal("webhook.test"),
+		Schema.Literal("domain.updated"),
+		Schema.Literal("domain.warming.updated"),
+		Schema.Literal("mailbox.message.received"),
+		Schema.Literal("mailbox.message.sent"),
+		Schema.Literal("mailbox.action.pending_approval"),
+		Schema.Literal("mailbox.message.quarantined"),
+		Schema.Literal("mailbox.message.released"),
+		Schema.Literal("mailbox.message.discarded"),
+		Schema.Literal("journey.webhook")
+	])),
+	channels: Schema.Union([Schema.Array(Schema.Literal("email")), Schema.Null]),
+	mailboxIds: Schema.Union([Schema.Array(MailboxId), Schema.Null]),
+	namespaceId: Schema.Union([NamespaceId, Schema.Null]),
+	status: Schema.Union([Schema.Literal("active"), Schema.Literal("disabled")]),
+	hasCustomHeaders: Schema.Boolean,
+	failureStartedAt: Schema.Union([Schema.String, Schema.Null]),
+	lastSucceededAt: Schema.Union([Schema.String, Schema.Null]),
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+	deliveries: WebhookDeliveryCounts
+}).annotate({ identifier: "WebhookEndpointListItem" });
+const WebhookDeliveryPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(Schema.Struct({
+		id: WebhookDeliveryId,
+		eventId: WebhookEventId,
+		eventType: Schema.String,
+		occurredAt: Schema.String,
+		endpointId: WebhookEndpointId,
+		status: Schema.Union([
+			Schema.Literal("pending"),
+			Schema.Literal("delivered"),
+			Schema.Literal("exhausted"),
+			Schema.Literal("cancelled")
+		]),
+		automaticAttempts: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+		nextAttemptAt: Schema.Union([Schema.String, Schema.Null]),
+		completedAt: Schema.Union([Schema.String, Schema.Null]),
+		createdAt: Schema.String,
+		updatedAt: Schema.String,
+		attempts: Schema.Array(Schema.Struct({
+			id: WebhookAttemptId,
+			deliveryId: WebhookDeliveryId,
+			kind: Schema.Union([Schema.Literal("automatic"), Schema.Literal("manual")]),
+			attemptNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThan(0).annotate({ expected: "a value greater than 0" })),
+			classification: Schema.Union([
+				Schema.Literal("success"),
+				Schema.Literal("http-error"),
+				Schema.Literal("network-error"),
+				Schema.Literal("timeout"),
+				Schema.Literal("cancelled")
+			]),
+			attemptedAt: Schema.String,
+			responseStatus: Schema.Union([Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })), Schema.Null]),
+			responseHeaders: Schema.Union([Schema.Record(Schema.String, Schema.String), Schema.Null]),
+			durationMs: Schema.Union([Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })), Schema.Null]),
+			errorCode: Schema.Union([Schema.String, Schema.Null]),
+			errorMessage: Schema.Union([Schema.String, Schema.Null]),
+			createdAt: Schema.String
+		}))
+	})),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "WebhookDeliveryPage" });
+const WebhookStatsResponse = /* @__PURE__ */ Schema.Struct({
+	total: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	pending: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	delivered: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	exhausted: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	cancelled: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	daily: Schema.Array(WebhookDailyDeliveries)
+}).annotate({ identifier: "WebhookStatsResponse" });
+const WebhookEndpointPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(WebhookEndpointListItem),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "WebhookEndpointPage" });
+const WebhooksListQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null])),
+	search: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	status: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Literal("active"), Schema.Literal("disabled")]), Schema.Null]))
+});
+const WebhooksList200 = WebhookEndpointPage;
+const WebhooksList401 = UnauthorizedError;
+const WebhooksList403 = ForbiddenError;
+const WebhooksList422 = ValidationError;
+const WebhooksList500 = InternalError;
+const WebhooksList504 = GatewayTimeoutError;
+const WebhooksCreateRequestJson = /* @__PURE__ */ Schema.Struct({
+	name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(100).annotate({ expected: "a string with at most 100 code points" })).check(Schema.isMaxLength(100).annotate({ expected: "a value with a length of at most 100" })),
+	url: Schema.String,
+	eventTypes: Schema.Array(Schema.Union([
+		Schema.Literal("message.sent"),
+		Schema.Literal("message.delivered"),
+		Schema.Literal("message.read"),
+		Schema.Literal("message.failed"),
+		Schema.Literal("message.bounced"),
+		Schema.Literal("message.complained"),
+		Schema.Literal("message.received"),
+		Schema.Literal("message.opened"),
+		Schema.Literal("message.clicked"),
+		Schema.Literal("contact.created"),
+		Schema.Literal("contact.updated"),
+		Schema.Literal("contact.deleted"),
+		Schema.Literal("contact.subscribed"),
+		Schema.Literal("contact.unsubscribed"),
+		Schema.Literal("contact.resubscribed"),
+		Schema.Literal("conversation.created"),
+		Schema.Literal("conversation.updated"),
+		Schema.Literal("conversation.archived"),
+		Schema.Literal("webhook.created"),
+		Schema.Literal("webhook.updated"),
+		Schema.Literal("webhook.deleted"),
+		Schema.Literal("webhook.test"),
+		Schema.Literal("domain.updated"),
+		Schema.Literal("domain.warming.updated"),
+		Schema.Literal("mailbox.message.received"),
+		Schema.Literal("mailbox.message.sent"),
+		Schema.Literal("mailbox.action.pending_approval"),
+		Schema.Literal("mailbox.message.quarantined"),
+		Schema.Literal("mailbox.message.released"),
+		Schema.Literal("mailbox.message.discarded"),
+		Schema.Literal("journey.webhook")
+	])).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+	channels: Schema.optionalKey(Schema.Union([Schema.Array(Schema.Literal("email")).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })), Schema.Null])),
+	mailboxIds: Schema.optionalKey(Schema.Union([Schema.TupleWithRest(Schema.Tuple([MailboxId]), [MailboxId]), Schema.Null])),
+	namespaceId: Schema.optionalKey(Schema.Union([NamespaceId, Schema.Null])),
+	headers: Schema.optionalKey(Schema.Union([Schema.Record(Schema.String, Schema.String), Schema.Null])),
+	status: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Literal("active"), Schema.Literal("disabled")]), Schema.Null]))
+});
+const WebhooksCreate201 = /* @__PURE__ */ Schema.Struct({
+	endpoint: WebhookEndpoint,
+	secret: SensitiveString
+});
+const WebhooksCreate401 = UnauthorizedError;
+const WebhooksCreate402 = PaymentRequiredError;
+const WebhooksCreate403 = ForbiddenError;
+const WebhooksCreate404 = ResourceNotFoundError;
+const WebhooksCreate409 = ConflictError;
+const WebhooksCreate422 = ValidationError;
+const WebhooksCreate500 = InternalError;
+const WebhooksCreate502 = BillingProviderError;
+const WebhooksCreate504 = GatewayTimeoutError;
+const WebhooksGetPathParams = /* @__PURE__ */ Schema.Struct({ id: WebhookEndpointId });
+const WebhooksGet200 = WebhookEndpoint;
+const WebhooksGet401 = UnauthorizedError;
+const WebhooksGet403 = ForbiddenError;
+const WebhooksGet404 = ResourceNotFoundError;
+const WebhooksGet422 = ValidationError;
+const WebhooksGet500 = InternalError;
+const WebhooksGet504 = GatewayTimeoutError;
+const WebhooksRemovePathParams = /* @__PURE__ */ Schema.Struct({ id: WebhookEndpointId });
+const WebhooksRemove200 = SuccessResponse;
+const WebhooksRemove401 = UnauthorizedError;
+const WebhooksRemove403 = ForbiddenError;
+const WebhooksRemove404 = ResourceNotFoundError;
+const WebhooksRemove422 = ValidationError;
+const WebhooksRemove500 = InternalError;
+const WebhooksRemove502 = BillingProviderError;
+const WebhooksRemove504 = GatewayTimeoutError;
+const WebhooksUpdatePathParams = /* @__PURE__ */ Schema.Struct({ id: WebhookEndpointId });
+const WebhooksUpdateRequestJson = /* @__PURE__ */ Schema.Struct({
+	name: Schema.optionalKey(Schema.Union([Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(100).annotate({ expected: "a string with at most 100 code points" })).check(Schema.isMaxLength(100).annotate({ expected: "a value with a length of at most 100" })), Schema.Null])),
+	url: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	eventTypes: Schema.optionalKey(Schema.Union([Schema.Array(Schema.Union([
+		Schema.Literal("message.sent"),
+		Schema.Literal("message.delivered"),
+		Schema.Literal("message.read"),
+		Schema.Literal("message.failed"),
+		Schema.Literal("message.bounced"),
+		Schema.Literal("message.complained"),
+		Schema.Literal("message.received"),
+		Schema.Literal("message.opened"),
+		Schema.Literal("message.clicked"),
+		Schema.Literal("contact.created"),
+		Schema.Literal("contact.updated"),
+		Schema.Literal("contact.deleted"),
+		Schema.Literal("contact.subscribed"),
+		Schema.Literal("contact.unsubscribed"),
+		Schema.Literal("contact.resubscribed"),
+		Schema.Literal("conversation.created"),
+		Schema.Literal("conversation.updated"),
+		Schema.Literal("conversation.archived"),
+		Schema.Literal("webhook.created"),
+		Schema.Literal("webhook.updated"),
+		Schema.Literal("webhook.deleted"),
+		Schema.Literal("webhook.test"),
+		Schema.Literal("domain.updated"),
+		Schema.Literal("domain.warming.updated"),
+		Schema.Literal("mailbox.message.received"),
+		Schema.Literal("mailbox.message.sent"),
+		Schema.Literal("mailbox.action.pending_approval"),
+		Schema.Literal("mailbox.message.quarantined"),
+		Schema.Literal("mailbox.message.released"),
+		Schema.Literal("mailbox.message.discarded"),
+		Schema.Literal("journey.webhook")
+	])).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })), Schema.Null])),
+	channels: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Array(Schema.Literal("email")).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })), Schema.Null]), Schema.Null])),
+	mailboxIds: Schema.optionalKey(Schema.Union([Schema.Union([Schema.TupleWithRest(Schema.Tuple([MailboxId]), [MailboxId]), Schema.Null]), Schema.Null])),
+	namespaceId: Schema.optionalKey(Schema.Union([Schema.Union([NamespaceId, Schema.Null]), Schema.Null])),
+	headers: Schema.optionalKey(Schema.Union([Schema.Record(Schema.String, Schema.String), Schema.Null])),
+	status: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Literal("active"), Schema.Literal("disabled")]), Schema.Null]))
+});
+const WebhooksUpdate200 = WebhookEndpoint;
+const WebhooksUpdate401 = UnauthorizedError;
+const WebhooksUpdate403 = ForbiddenError;
+const WebhooksUpdate404 = ResourceNotFoundError;
+const WebhooksUpdate409 = ConflictError;
+const WebhooksUpdate422 = ValidationError;
+const WebhooksUpdate500 = InternalError;
+const WebhooksUpdate504 = GatewayTimeoutError;
+const WebhooksRetryDeliveryPathParams = /* @__PURE__ */ Schema.Struct({
+	id: WebhookEndpointId,
+	deliveryId: WebhookDeliveryId
+});
+const WebhooksRetryDelivery200 = /* @__PURE__ */ Schema.Struct({
+	accepted: Schema.Literal(true),
+	deliveryId: WebhookDeliveryId,
+	attemptId: WebhookAttemptId,
+	outcome: Schema.Union([Schema.Literal("succeeded"), Schema.Literal("failed")])
+});
+const WebhooksRetryDelivery401 = UnauthorizedError;
+const WebhooksRetryDelivery403 = ForbiddenError;
+const WebhooksRetryDelivery404 = ResourceNotFoundError;
+const WebhooksRetryDelivery422 = ValidationError;
+const WebhooksRetryDelivery429 = RateLimitedError;
+const WebhooksRetryDelivery500 = InternalError;
+const WebhooksRetryDelivery504 = GatewayTimeoutError;
+const WebhooksGetLogsPathParams = /* @__PURE__ */ Schema.Struct({ id: WebhookEndpointId });
+const WebhooksGetLogsQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null]))
+});
+const WebhooksGetLogs200 = WebhookDeliveryPage;
+const WebhooksGetLogs401 = UnauthorizedError;
+const WebhooksGetLogs403 = ForbiddenError;
+const WebhooksGetLogs404 = ResourceNotFoundError;
+const WebhooksGetLogs422 = ValidationError;
+const WebhooksGetLogs500 = InternalError;
+const WebhooksGetLogs504 = GatewayTimeoutError;
+const WebhooksRegenerateSecretPathParams = /* @__PURE__ */ Schema.Struct({ id: WebhookEndpointId });
+const WebhooksRegenerateSecret200 = /* @__PURE__ */ Schema.Struct({ secret: SensitiveString });
+const WebhooksRegenerateSecret401 = UnauthorizedError;
+const WebhooksRegenerateSecret403 = ForbiddenError;
+const WebhooksRegenerateSecret404 = ResourceNotFoundError;
+const WebhooksRegenerateSecret422 = ValidationError;
+const WebhooksRegenerateSecret500 = InternalError;
+const WebhooksRegenerateSecret504 = GatewayTimeoutError;
+const WebhooksGetStatsPathParams = /* @__PURE__ */ Schema.Struct({ id: WebhookEndpointId });
+const WebhooksGetStatsQuery = /* @__PURE__ */ Schema.Struct({
+	after: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	before: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+});
+const WebhooksGetStats200 = WebhookStatsResponse;
+const WebhooksGetStats401 = UnauthorizedError;
+const WebhooksGetStats403 = ForbiddenError;
+const WebhooksGetStats404 = ResourceNotFoundError;
+const WebhooksGetStats422 = ValidationError;
+const WebhooksGetStats500 = InternalError;
+const WebhooksGetStats504 = GatewayTimeoutError;
+const WebhooksTestPathParams = /* @__PURE__ */ Schema.Struct({ id: WebhookEndpointId });
+const WebhooksTestRequestJson = /* @__PURE__ */ Schema.Struct({ data: Schema.optionalKey(Schema.Union([Schema.Record(Schema.String, JsonValue), Schema.Null])) });
+const WebhooksTest202 = /* @__PURE__ */ Schema.Struct({
+	accepted: Schema.Literal(true),
+	eventId: WebhookEventId,
+	deliveryId: WebhookDeliveryId
+});
+const WebhooksTest401 = UnauthorizedError;
+const WebhooksTest403 = ForbiddenError;
+const WebhooksTest404 = ResourceNotFoundError;
+const WebhooksTest422 = ValidationError;
+const WebhooksTest500 = InternalError;
+const WebhooksTest504 = GatewayTimeoutError;
+var WebhooksGroup = class extends HttpApiGroup.make("Webhooks").add(HttpApiEndpoint.get("webhooksList", "/v1/webhooks", {
+	query: WebhooksListQuery,
+	success: WebhooksList200,
+	error: [
+		WebhooksList401.pipe(HttpApiSchema.status(401)),
+		WebhooksList403.pipe(HttpApiSchema.status(403)),
+		WebhooksList422.pipe(HttpApiSchema.status(422)),
+		WebhooksList500,
+		WebhooksList504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "webhooks.list").annotate(OpenApi.Summary, "List webhooks").annotate(OpenApi.Description, "Returns the organization's webhook endpoints, oldest first, with each endpoint's delivery counts, optionally filtered by a search term matched against name and URL, and by status. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page."), HttpApiEndpoint.post("webhooksCreate", "/v1/webhooks", {
+	payload: WebhooksCreateRequestJson,
+	success: WebhooksCreate201.pipe(HttpApiSchema.status(201)),
+	error: [
+		WebhooksCreate401.pipe(HttpApiSchema.status(401)),
+		WebhooksCreate402.pipe(HttpApiSchema.status(402)),
+		WebhooksCreate403.pipe(HttpApiSchema.status(403)),
+		WebhooksCreate404.pipe(HttpApiSchema.status(404)),
+		WebhooksCreate409.pipe(HttpApiSchema.status(409)),
+		WebhooksCreate422.pipe(HttpApiSchema.status(422)),
+		WebhooksCreate500,
+		WebhooksCreate502.pipe(HttpApiSchema.status(502)),
+		WebhooksCreate504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "webhooks.create").annotate(OpenApi.Summary, "Create a webhook").annotate(OpenApi.Description, "Creates a signed webhook endpoint for Samva delivery and inbound events, stores subscriptions, and returns the endpoint and signing secret with a 201 response. `mailboxIds` and `namespaceId` confine mailbox events; when both are set, every mailbox must belong to the namespace."), HttpApiEndpoint.get("webhooksGet", "/v1/webhooks/:id", {
+	params: WebhooksGetPathParams,
+	success: WebhooksGet200,
+	error: [
+		WebhooksGet401.pipe(HttpApiSchema.status(401)),
+		WebhooksGet403.pipe(HttpApiSchema.status(403)),
+		WebhooksGet404.pipe(HttpApiSchema.status(404)),
+		WebhooksGet422.pipe(HttpApiSchema.status(422)),
+		WebhooksGet500,
+		WebhooksGet504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "webhooks.get").annotate(OpenApi.Summary, "Get a webhook").annotate(OpenApi.Description, "Returns the configuration of the webhook endpoint with the given ID."), HttpApiEndpoint.delete("webhooksRemove", "/v1/webhooks/:id", {
+	params: WebhooksRemovePathParams,
+	success: WebhooksRemove200,
+	error: [
+		WebhooksRemove401.pipe(HttpApiSchema.status(401)),
+		WebhooksRemove403.pipe(HttpApiSchema.status(403)),
+		WebhooksRemove404.pipe(HttpApiSchema.status(404)),
+		WebhooksRemove422.pipe(HttpApiSchema.status(422)),
+		WebhooksRemove500,
+		WebhooksRemove502.pipe(HttpApiSchema.status(502)),
+		WebhooksRemove504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "webhooks.remove").annotate(OpenApi.Summary, "Delete a webhook").annotate(OpenApi.Description, "Deletes a webhook endpoint so it no longer receives event deliveries."), HttpApiEndpoint.patch("webhooksUpdate", "/v1/webhooks/:id", {
+	params: WebhooksUpdatePathParams,
+	payload: WebhooksUpdateRequestJson,
+	success: WebhooksUpdate200,
+	error: [
+		WebhooksUpdate401.pipe(HttpApiSchema.status(401)),
+		WebhooksUpdate403.pipe(HttpApiSchema.status(403)),
+		WebhooksUpdate404.pipe(HttpApiSchema.status(404)),
+		WebhooksUpdate409.pipe(HttpApiSchema.status(409)),
+		WebhooksUpdate422.pipe(HttpApiSchema.status(422)),
+		WebhooksUpdate500,
+		WebhooksUpdate504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "webhooks.update").annotate(OpenApi.Summary, "Update a webhook").annotate(OpenApi.Description, "Updates a webhook's name, URL, subscribed events, channels, custom headers, mailbox scope, or status and returns the updated endpoint. A change to `mailboxIds` or `namespaceId` is checked as the endpoint will stand afterward: every mailbox must belong to the namespace when both are set."), HttpApiEndpoint.post("webhooksRetryDelivery", "/v1/webhooks/:id/deliveries/:deliveryId/redeliver", {
+	params: WebhooksRetryDeliveryPathParams,
+	success: WebhooksRetryDelivery200,
+	error: [
+		WebhooksRetryDelivery401.pipe(HttpApiSchema.status(401)),
+		WebhooksRetryDelivery403.pipe(HttpApiSchema.status(403)),
+		WebhooksRetryDelivery404.pipe(HttpApiSchema.status(404)),
+		WebhooksRetryDelivery422.pipe(HttpApiSchema.status(422)),
+		WebhooksRetryDelivery429.pipe(HttpApiSchema.status(429)),
+		WebhooksRetryDelivery500,
+		WebhooksRetryDelivery504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "webhooks.retryDelivery").annotate(OpenApi.Summary, "Retry a webhook delivery").annotate(OpenApi.Description, "Performs one immediate manual redelivery attempt and returns that attempt's identity and outcome without changing the automatic retry lifecycle."), HttpApiEndpoint.get("webhooksGetLogs", "/v1/webhooks/:id/logs", {
+	params: WebhooksGetLogsPathParams,
+	query: WebhooksGetLogsQuery,
+	success: WebhooksGetLogs200,
+	error: [
+		WebhooksGetLogs401.pipe(HttpApiSchema.status(401)),
+		WebhooksGetLogs403.pipe(HttpApiSchema.status(403)),
+		WebhooksGetLogs404.pipe(HttpApiSchema.status(404)),
+		WebhooksGetLogs422.pipe(HttpApiSchema.status(422)),
+		WebhooksGetLogs500,
+		WebhooksGetLogs504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "webhooks.getLogs").annotate(OpenApi.Summary, "List webhook delivery logs").annotate(OpenApi.Description, "Returns a webhook endpoint's deliveries, newest first, each naming the event type and time it was made for, with its nested attempt diagnostics. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page."), HttpApiEndpoint.post("webhooksRegenerateSecret", "/v1/webhooks/:id/rotate-secret", {
+	params: WebhooksRegenerateSecretPathParams,
+	success: WebhooksRegenerateSecret200,
+	error: [
+		WebhooksRegenerateSecret401.pipe(HttpApiSchema.status(401)),
+		WebhooksRegenerateSecret403.pipe(HttpApiSchema.status(403)),
+		WebhooksRegenerateSecret404.pipe(HttpApiSchema.status(404)),
+		WebhooksRegenerateSecret422.pipe(HttpApiSchema.status(422)),
+		WebhooksRegenerateSecret500,
+		WebhooksRegenerateSecret504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "webhooks.regenerateSecret").annotate(OpenApi.Summary, "Rotate a webhook signing secret").annotate(OpenApi.Description, "Generates and returns a new signing secret. The previous secret remains valid for a 24-hour rotation overlap."), HttpApiEndpoint.get("webhooksGetStats", "/v1/webhooks/:id/stats", {
+	params: WebhooksGetStatsPathParams,
+	query: WebhooksGetStatsQuery,
+	success: WebhooksGetStats200,
+	error: [
+		WebhooksGetStats401.pipe(HttpApiSchema.status(401)),
+		WebhooksGetStats403.pipe(HttpApiSchema.status(403)),
+		WebhooksGetStats404.pipe(HttpApiSchema.status(404)),
+		WebhooksGetStats422.pipe(HttpApiSchema.status(422)),
+		WebhooksGetStats500,
+		WebhooksGetStats504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "webhooks.getStats").annotate(OpenApi.Summary, "Get webhook delivery statistics").annotate(OpenApi.Description, "Returns aggregate pending, delivered, exhausted, and cancelled delivery counts for a webhook endpoint over its whole retained history, plus the same counts per organization-local calendar day between `after` and `before`, a window of at most 90 days that defaults to the last 30 days. Deliveries are retained for 90 days, so the longest window is the whole history."), HttpApiEndpoint.post("webhooksTest", "/v1/webhooks/:id/test", {
+	params: WebhooksTestPathParams,
+	payload: WebhooksTestRequestJson,
+	success: WebhooksTest202.pipe(HttpApiSchema.status(202)),
+	error: [
+		WebhooksTest401.pipe(HttpApiSchema.status(401)),
+		WebhooksTest403.pipe(HttpApiSchema.status(403)),
+		WebhooksTest404.pipe(HttpApiSchema.status(404)),
+		WebhooksTest422.pipe(HttpApiSchema.status(422)),
+		WebhooksTest500,
+		WebhooksTest504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "webhooks.test").annotate(OpenApi.Summary, "Send a test webhook delivery").annotate(OpenApi.Description, "Queues a signed webhook.test event through the normal delivery and retry lifecycle.")).annotate(OpenApi.Description, "Customer event webhook management, testing, and delivery logs") {};
+//#endregion
+//#region src/effect/webhooks.ts
+var webhooks_exports = /* @__PURE__ */ __exportAll({
+	CreatePayload: () => CreateWebhookPayload,
+	TestPayload: () => TestWebhookPayload,
+	UpdatePayload: () => UpdateWebhookPayload,
+	create: () => create,
+	get: () => get,
+	getLogs: () => getLogs,
+	getStats: () => getStats,
+	list: () => list,
+	regenerateSecret: () => regenerateSecret,
+	remove: () => remove,
+	retryDelivery: () => retryDelivery,
+	test: () => test,
+	update: () => update
+});
+const make = forGroup(WebhooksGroup);
+const list = make("webhooksList");
+const create = make("webhooksCreate");
+const get = make("webhooksGet");
+const remove = make("webhooksRemove");
+const update = make("webhooksUpdate");
+const test = make("webhooksTest");
+const getLogs = make("webhooksGetLogs");
+const getStats = make("webhooksGetStats");
+const retryDelivery = make("webhooksRetryDelivery");
+const regenerateSecret = make("webhooksRegenerateSecret");
+//#endregion
+export { list as a, retryDelivery as c, webhooks_exports as d, getStats as i, test as l, get as n, regenerateSecret as o, getLogs as r, remove as s, create as t, update as u };
+
+//# sourceMappingURL=webhooks-CPXuu8Xf.js.map

package/dist/whoami-Ccz0jwlt.js

@@ -0,0 +1,59 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { Jt as UnauthorizedError, K as ForbiddenError, Mt as OrganizationId, Y as InternalError, a as ApiKeyAccess, en as ValidationError, q as GatewayTimeoutError, s as ApiKeySecurityMiddleware } from "./client-DOzUrdTE.js";
+import { n as forGroup } from "./operation-n_IYgNVK.js";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/whoami.ts
+const WhoamiUser = /* @__PURE__ */ Schema.Struct({
+	id: Schema.String,
+	name: Schema.String,
+	email: Schema.String
+}).annotate({ identifier: "WhoamiUser" });
+const WhoamiOrganization = /* @__PURE__ */ Schema.Struct({
+	id: OrganizationId,
+	slug: Schema.String,
+	name: Schema.String
+}).annotate({ identifier: "WhoamiOrganization" });
+const WhoamiUserCredential = /* @__PURE__ */ Schema.Struct({
+	type: Schema.Literal("user"),
+	user: WhoamiUser,
+	role: Schema.Union([
+		Schema.Literal("member"),
+		Schema.Literal("admin"),
+		Schema.Literal("owner")
+	])
+}).annotate({ identifier: "WhoamiUserCredential" });
+const WhoamiApiKeyCredential = /* @__PURE__ */ Schema.Struct({
+	type: Schema.Literal("apiKey"),
+	id: Schema.String,
+	name: Schema.String,
+	start: Schema.Union([Schema.String, Schema.Null]),
+	access: ApiKeyAccess
+}).annotate({ identifier: "WhoamiApiKeyCredential" });
+const WhoamiGet200 = /* @__PURE__ */ Schema.Struct({
+	organization: WhoamiOrganization,
+	credential: Schema.Union([WhoamiApiKeyCredential, WhoamiUserCredential])
+}).annotate({ identifier: "Whoami" });
+const WhoamiGet401 = UnauthorizedError;
+const WhoamiGet403 = ForbiddenError;
+const WhoamiGet422 = ValidationError;
+const WhoamiGet500 = InternalError;
+const WhoamiGet504 = GatewayTimeoutError;
+var WhoamiGroup = class extends HttpApiGroup.make("Whoami").add(HttpApiEndpoint.get("whoamiGet", "/v1/whoami", {
+	success: WhoamiGet200,
+	error: [
+		WhoamiGet401.pipe(HttpApiSchema.status(401)),
+		WhoamiGet403.pipe(HttpApiSchema.status(403)),
+		WhoamiGet422.pipe(HttpApiSchema.status(422)),
+		WhoamiGet500,
+		WhoamiGet504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "whoami.get").annotate(OpenApi.Summary, "Get the calling credential").annotate(OpenApi.Description, "Returns the organization the request acts in and the credential it presents: an API key with its name, prefix, and access, or a signed-in user with their role. Any valid credential may call it, whatever its grants.")).annotate(OpenApi.Description, "The organization and credential behind the request.") {};
+//#endregion
+//#region src/effect/whoami.ts
+var whoami_exports = /* @__PURE__ */ __exportAll({ get: () => get });
+const get = forGroup(WhoamiGroup)("whoamiGet");
+//#endregion
+export { whoami_exports as n, get as t };
+
+//# sourceMappingURL=whoami-Ccz0jwlt.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "samva",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "TypeScript SDK for the Samva email API",
   "keywords": [
     "api-client",
@@ -33,6 +33,7 @@
     "LICENSE"
   ],
   "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -106,10 +107,18 @@
       "types": "./dist/effect/extensions.d.ts",
       "import": "./dist/effect/extensions.js"
     },
+    "./effect/events": {
+      "types": "./dist/effect/events.d.ts",
+      "import": "./dist/effect/events.js"
+    },
     "./effect/feedback": {
       "types": "./dist/effect/feedback.d.ts",
       "import": "./dist/effect/feedback.js"
     },
+    "./effect/journeys": {
+      "types": "./dist/effect/journeys.d.ts",
+      "import": "./dist/effect/journeys.js"
+    },
     "./effect/mailboxes": {
       "types": "./dist/effect/mailboxes.d.ts",
       "import": "./dist/effect/mailboxes.js"
@@ -154,6 +163,10 @@
       "types": "./dist/effect/webhooks.d.ts",
       "import": "./dist/effect/webhooks.js"
     },
+    "./effect/whoami": {
+      "types": "./dist/effect/whoami.d.ts",
+      "import": "./dist/effect/whoami.js"
+    },
     "./webhooks": {
       "types": "./dist/webhooks/promise.d.ts",
       "import": "./dist/webhooks/promise.js"
@@ -171,18 +184,19 @@
     "prepack": "bun run build",
     "generate:openapi": "bun run scripts/openapi.ts",
     "generate:promises": "bun run codegen/generate-promises.ts && bun run scripts/generate-promise-errors.ts && oxfmt --config=../../oxfmt.config.ts src/client src/promises/errors.gen.ts src/promises/types.gen.ts",
-    "generate:effect": "bun run codegen/generate-effect.ts && oxfmt --config=../../oxfmt.config.ts src/effect/generated.ts src/effect/generated-metadata.ts && bun run codegen/normalize-effect.ts",
+    "generate:effect": "bun run codegen/generate-effect.ts && oxfmt --config=../../oxfmt.config.ts src/effect/generated src/effect/generated-metadata.ts && bun run codegen/normalize-effect.ts",
     "generate": "bun generate:openapi && bun generate:promises && bun generate:effect",
     "test": "vitest run --root ../.. --project packages",
     "test:generation": "bun scripts/check-generation.ts",
     "test:packed": "bun run build && bun scripts/test-packed-consumers.ts",
     "test:tarball": "bun run build && bun scripts/check-tarball.ts",
+    "test:startup": "bun run build && bun scripts/check-startup.ts",
     "test:tree-shaking": "bun run build && bun scripts/check-tree-shaking.ts",
     "test:types": "tsc --noEmit --project tests/parity/tsconfig.json",
     "typecheck": "tsc --noEmit && tsc --noEmit -p codegen/tsconfig.json && tsc --noEmit -p tests/tsconfig.json"
   },
   "dependencies": {
-    "@samva/webhooks": "0.15.0"
+    "@samva/webhooks": "0.17.0"
   },
   "devDependencies": {
     "@effect/openapi-generator": "4.0.0",