samva 0.16.0 → 0.17.0

package/dist/campaigns-DZlz1E9E.js

@@ -0,0 +1,522 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { t as AbsoluteInstant } from "./runtime-P0l1_2-C.js";
+import { Bt as SendsSeries, D as Cursor, F as EmailDomainId, G as FlagDisabledError, Jt as UnauthorizedError, K as ForbiddenError, Lt as ResourceNotFoundError, N as EmailContent, P as EmailDispatchContent, U as ExternalServiceError, Y as InternalError, Yt as UnsubscribeId, _ as ContactGroupId, en as ValidationError, et as JsonValue, m as ConflictError, p as CampaignFooterRequiredError, q as GatewayTimeoutError, s as ApiKeySecurityMiddleware, u as BrandAddressRequiredError, v as ContactId, x as ConversationId, zt as SenderNotReadyError } 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/campaigns.ts
+const CampaignId = /* @__PURE__ */ Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^camp_[0-9a-hjkmnp-tv-z]{16,24}$", "u")).annotate({
+	expected: "a string matching the RegExp ^camp_[0-9a-hjkmnp-tv-z]{16,24}$",
+	identifier: "CampaignId"
+})).pipe(Schema.brand("CampaignId"));
+const CampaignContentMetadata = /* @__PURE__ */ Schema.Union([Schema.Record(Schema.String, JsonValue), Schema.Null]).annotate({ identifier: "CampaignContentMetadata" });
+const CampaignDefinitionSummary = /* @__PURE__ */ Schema.Struct({
+	state: Schema.Union([
+		Schema.Literal("editable"),
+		Schema.Literal("frozen"),
+		Schema.Literal("archived")
+	]),
+	frozenAt: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "CampaignDefinitionSummary" });
+const CampaignRunId = /* @__PURE__ */ Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^crun_[0-9a-hjkmnp-tv-z]{16,24}$", "u")).annotate({
+	expected: "a string matching the RegExp ^crun_[0-9a-hjkmnp-tv-z]{16,24}$",
+	identifier: "CampaignRunId"
+})).pipe(Schema.brand("CampaignRunId"));
+const CampaignRecipientId = /* @__PURE__ */ Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^crcpt_[0-9a-hjkmnp-tv-z]{16,24}$", "u")).annotate({
+	expected: "a string matching the RegExp ^crcpt_[0-9a-hjkmnp-tv-z]{16,24}$",
+	identifier: "CampaignRecipientId"
+})).pipe(Schema.brand("CampaignRecipientId"));
+const CampaignPolicy = /* @__PURE__ */ Schema.Struct({
+	unsubscribeGroupId: Schema.optionalKey(Schema.Union([UnsubscribeId, Schema.Null])),
+	pageSize: Schema.optionalKey(Schema.Union([Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(100).annotate({ expected: "a value greater than or equal to 100" })).check(Schema.isLessThanOrEqualTo(1e3).annotate({ expected: "a value less than or equal to 1000" })), Schema.Null]))
+}).annotate({ identifier: "CampaignPolicy" });
+const CampaignConversationRef = /* @__PURE__ */ Schema.Union([Schema.Union([ConversationId, Schema.Null]), Schema.Null]).annotate({ identifier: "CampaignConversationRef" });
+const CampaignAudience = /* @__PURE__ */ Schema.Struct({
+	includeTags: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	excludeTags: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	contactIds: Schema.optionalKey(Schema.Union([Schema.Array(ContactId).check(Schema.isMaxLength(25e3).annotate({ expected: "a value with a length of at most 25000" })), Schema.Null])),
+	groupIds: Schema.optionalKey(Schema.Union([Schema.Array(ContactGroupId).check(Schema.isMaxLength(100).annotate({ expected: "a value with a length of at most 100" })), Schema.Null]))
+}).annotate({ identifier: "CampaignAudience" });
+const CampaignLatestRun = /* @__PURE__ */ Schema.Struct({
+	id: CampaignRunId,
+	status: Schema.Union([
+		Schema.Literal("scheduled"),
+		Schema.Literal("resolving"),
+		Schema.Literal("dispatching"),
+		Schema.Literal("paused"),
+		Schema.Literal("completed"),
+		Schema.Literal("cancelled"),
+		Schema.Literal("failed")
+	]),
+	scheduledFor: Schema.String,
+	completedAt: Schema.Union([Schema.String, Schema.Null]),
+	totalRecipients: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+	dispatchedCount: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+	failedCount: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+	skippedCount: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+	estimatedCompletionAt: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "CampaignLatestRun" });
+const CampaignRecipientPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(Schema.Struct({
+		id: CampaignRecipientId,
+		runId: CampaignRunId,
+		contactId: ContactId,
+		status: Schema.Union([
+			Schema.Literal("pending"),
+			Schema.Literal("dispatching"),
+			Schema.Literal("dispatched"),
+			Schema.Literal("failed"),
+			Schema.Literal("skipped")
+		]),
+		messageId: Schema.Union([Schema.String, Schema.Null]),
+		failureReason: Schema.Union([Schema.String, Schema.Null]),
+		skippedReason: Schema.Union([Schema.Union([
+			Schema.Literal("unsubscribed"),
+			Schema.Literal("blocked"),
+			Schema.Literal("suppressed"),
+			Schema.Literal("no_identity"),
+			Schema.Literal("inactive"),
+			Schema.Literal("run_cancelled"),
+			Schema.Literal("run_failed")
+		]), Schema.Null]),
+		createdAt: Schema.String,
+		updatedAt: Schema.String
+	})),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "CampaignRecipientPage" });
+const CampaignContent = /* @__PURE__ */ Schema.Struct({
+	channel: Schema.Literal("email"),
+	email: EmailContent,
+	conversationId: Schema.optionalKey(CampaignConversationRef),
+	metadata: Schema.optionalKey(CampaignContentMetadata)
+}).annotate({ identifier: "CampaignContent" });
+const CampaignContentInput = /* @__PURE__ */ Schema.Struct({
+	channel: Schema.Literal("email"),
+	email: EmailDispatchContent,
+	conversationId: Schema.optionalKey(CampaignConversationRef),
+	metadata: Schema.optionalKey(CampaignContentMetadata)
+}).annotate({ identifier: "CampaignContentInput" });
+const CampaignListItem = /* @__PURE__ */ Schema.Struct({
+	id: CampaignId,
+	name: Schema.String,
+	channel: Schema.Literal("email"),
+	content: CampaignContent,
+	audience: CampaignAudience,
+	policy: CampaignPolicy,
+	definition: CampaignDefinitionSummary,
+	latestRun: Schema.Union([CampaignLatestRun, Schema.Null]),
+	createdBy: Schema.Union([Schema.String, Schema.Null]),
+	actorEmail: Schema.String,
+	memberRole: Schema.String,
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+	series: SendsSeries
+}).annotate({ identifier: "CampaignListItem" });
+const Campaign = /* @__PURE__ */ Schema.Struct({
+	id: CampaignId,
+	name: Schema.String,
+	channel: Schema.Literal("email"),
+	content: CampaignContent,
+	audience: CampaignAudience,
+	policy: CampaignPolicy,
+	definition: CampaignDefinitionSummary,
+	latestRun: Schema.Union([CampaignLatestRun, Schema.Null]),
+	createdBy: Schema.Union([Schema.String, Schema.Null]),
+	actorEmail: Schema.String,
+	memberRole: Schema.String,
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+}).annotate({ identifier: "Campaign" });
+const CampaignRun = /* @__PURE__ */ Schema.Struct({
+	id: CampaignRunId,
+	campaignId: CampaignId,
+	status: Schema.Union([
+		Schema.Literal("scheduled"),
+		Schema.Literal("resolving"),
+		Schema.Literal("dispatching"),
+		Schema.Literal("paused"),
+		Schema.Literal("completed"),
+		Schema.Literal("cancelled"),
+		Schema.Literal("failed")
+	]),
+	scheduledFor: Schema.String,
+	idempotencyKey: Schema.Union([Schema.String, Schema.Null]),
+	startedAt: Schema.Union([Schema.String, Schema.Null]),
+	completedAt: Schema.Union([Schema.String, Schema.Null]),
+	contentSnapshot: CampaignContent,
+	audienceSnapshot: CampaignAudience,
+	policySnapshot: CampaignPolicy,
+	totalRecipients: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+	dispatchedCount: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+	failedCount: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+	skippedCount: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+	estimatedCompletionAt: Schema.Union([Schema.String, Schema.Null]),
+	failureReason: Schema.Union([Schema.String, Schema.Null]),
+	holdReason: Schema.Union([Schema.String, Schema.Null]),
+	holdDomainId: Schema.Union([EmailDomainId, Schema.Null]),
+	lastContactId: Schema.Union([Schema.String, Schema.Null]),
+	createdBy: Schema.Union([Schema.String, Schema.Null]),
+	actorEmail: Schema.String,
+	memberRole: Schema.String,
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+}).annotate({ identifier: "CampaignRun" });
+const CampaignPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(CampaignListItem),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "CampaignPage" });
+const CampaignRunPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(CampaignRun),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "CampaignRunPage" });
+const CampaignRunAction = /* @__PURE__ */ Schema.Struct({
+	success: Schema.Boolean,
+	item: CampaignRun
+}).annotate({ identifier: "CampaignRunAction" });
+const CampaignsListQuery = /* @__PURE__ */ Schema.Struct({
+	status: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Literal("draft"), Schema.Literal("archived")]), Schema.Null])),
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null]))
+});
+const CampaignsList200 = CampaignPage;
+const CampaignsList401 = UnauthorizedError;
+const CampaignsList403 = ForbiddenError;
+const CampaignsList422 = ValidationError;
+const CampaignsList500 = InternalError;
+const CampaignsList504 = GatewayTimeoutError;
+const CampaignsCreateRequestJson = /* @__PURE__ */ Schema.Struct({
+	name: Schema.String,
+	channel: Schema.Literal("email"),
+	content: CampaignContentInput,
+	audience: CampaignAudience,
+	policy: Schema.optionalKey(Schema.Union([CampaignPolicy, Schema.Null]))
+});
+const CampaignsCreate201 = Campaign;
+const CampaignsCreate401 = UnauthorizedError;
+const CampaignsCreate403 = /* @__PURE__ */ Schema.Union([FlagDisabledError, ForbiddenError]);
+const CampaignsCreate422 = ValidationError;
+const CampaignsCreate500 = InternalError;
+const CampaignsCreate504 = GatewayTimeoutError;
+const CampaignsGetPathParams = /* @__PURE__ */ Schema.Struct({ id: CampaignId });
+const CampaignsGet200 = Campaign;
+const CampaignsGet401 = UnauthorizedError;
+const CampaignsGet403 = ForbiddenError;
+const CampaignsGet404 = ResourceNotFoundError;
+const CampaignsGet422 = ValidationError;
+const CampaignsGet500 = InternalError;
+const CampaignsGet504 = GatewayTimeoutError;
+const CampaignsUpdatePathParams = /* @__PURE__ */ Schema.Struct({ id: CampaignId });
+const CampaignsUpdateRequestJson = /* @__PURE__ */ Schema.Struct({
+	name: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	content: Schema.optionalKey(Schema.Union([CampaignContentInput, Schema.Null])),
+	audience: Schema.optionalKey(Schema.Union([CampaignAudience, Schema.Null])),
+	policy: Schema.optionalKey(Schema.Union([CampaignPolicy, Schema.Null]))
+});
+const CampaignsUpdate200 = Campaign;
+const CampaignsUpdate401 = UnauthorizedError;
+const CampaignsUpdate403 = /* @__PURE__ */ Schema.Union([FlagDisabledError, ForbiddenError]);
+const CampaignsUpdate404 = ResourceNotFoundError;
+const CampaignsUpdate409 = ConflictError;
+const CampaignsUpdate422 = ValidationError;
+const CampaignsUpdate500 = InternalError;
+const CampaignsUpdate504 = GatewayTimeoutError;
+const CampaignsArchivePathParams = /* @__PURE__ */ Schema.Struct({ id: CampaignId });
+const CampaignsArchive200 = Campaign;
+const CampaignsArchive401 = UnauthorizedError;
+const CampaignsArchive403 = ForbiddenError;
+const CampaignsArchive404 = ResourceNotFoundError;
+const CampaignsArchive409 = ConflictError;
+const CampaignsArchive422 = ValidationError;
+const CampaignsArchive500 = InternalError;
+const CampaignsArchive504 = GatewayTimeoutError;
+const CampaignsListRunsPathParams = /* @__PURE__ */ Schema.Struct({ id: CampaignId });
+const CampaignsListRunsQuery = /* @__PURE__ */ Schema.Struct({
+	status: Schema.optionalKey(Schema.Union([Schema.Union([
+		Schema.Literal("scheduled"),
+		Schema.Literal("resolving"),
+		Schema.Literal("dispatching"),
+		Schema.Literal("paused"),
+		Schema.Literal("completed"),
+		Schema.Literal("cancelled"),
+		Schema.Literal("failed")
+	]), Schema.Null])),
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null]))
+});
+const CampaignsListRuns200 = CampaignRunPage;
+const CampaignsListRuns401 = UnauthorizedError;
+const CampaignsListRuns403 = ForbiddenError;
+const CampaignsListRuns404 = ResourceNotFoundError;
+const CampaignsListRuns422 = ValidationError;
+const CampaignsListRuns500 = InternalError;
+const CampaignsListRuns504 = GatewayTimeoutError;
+const CampaignsScheduleRunPathParams = /* @__PURE__ */ Schema.Struct({ id: CampaignId });
+const CampaignsScheduleRunRequestJson = /* @__PURE__ */ Schema.Struct({
+	scheduledFor: Schema.optionalKey(Schema.Union([AbsoluteInstant, Schema.Null])),
+	idempotencyKey: Schema.optionalKey(Schema.Union([Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[\\s\\S]{1,255}$")).annotate({ expected: "a string matching the RegExp ^[\\s\\S]{1,255}$" })), Schema.Null]))
+});
+const CampaignsScheduleRun201 = CampaignRun;
+const CampaignsScheduleRun401 = UnauthorizedError;
+const CampaignsScheduleRun403 = /* @__PURE__ */ Schema.Union([FlagDisabledError, ForbiddenError]);
+const CampaignsScheduleRun404 = ResourceNotFoundError;
+const CampaignsScheduleRun409 = ConflictError;
+const CampaignsScheduleRun422 = /* @__PURE__ */ Schema.Union([
+	ValidationError,
+	BrandAddressRequiredError,
+	CampaignFooterRequiredError
+]);
+const CampaignsScheduleRun500 = InternalError;
+const CampaignsScheduleRun502 = ExternalServiceError;
+const CampaignsScheduleRun503 = SenderNotReadyError;
+const CampaignsScheduleRun504 = GatewayTimeoutError;
+const CampaignsGetRunPathParams = /* @__PURE__ */ Schema.Struct({
+	id: CampaignId,
+	runId: CampaignRunId
+});
+const CampaignsGetRun200 = CampaignRun;
+const CampaignsGetRun401 = UnauthorizedError;
+const CampaignsGetRun403 = ForbiddenError;
+const CampaignsGetRun404 = ResourceNotFoundError;
+const CampaignsGetRun422 = ValidationError;
+const CampaignsGetRun500 = InternalError;
+const CampaignsGetRun504 = GatewayTimeoutError;
+const CampaignsCancelRunPathParams = /* @__PURE__ */ Schema.Struct({
+	id: CampaignId,
+	runId: CampaignRunId
+});
+const CampaignsCancelRun200 = CampaignRunAction;
+const CampaignsCancelRun401 = UnauthorizedError;
+const CampaignsCancelRun403 = ForbiddenError;
+const CampaignsCancelRun404 = ResourceNotFoundError;
+const CampaignsCancelRun409 = ConflictError;
+const CampaignsCancelRun422 = ValidationError;
+const CampaignsCancelRun500 = InternalError;
+const CampaignsCancelRun502 = ExternalServiceError;
+const CampaignsCancelRun504 = GatewayTimeoutError;
+const CampaignsPauseRunPathParams = /* @__PURE__ */ Schema.Struct({
+	id: CampaignId,
+	runId: CampaignRunId
+});
+const CampaignsPauseRun200 = CampaignRunAction;
+const CampaignsPauseRun401 = UnauthorizedError;
+const CampaignsPauseRun403 = ForbiddenError;
+const CampaignsPauseRun404 = ResourceNotFoundError;
+const CampaignsPauseRun409 = ConflictError;
+const CampaignsPauseRun422 = ValidationError;
+const CampaignsPauseRun500 = InternalError;
+const CampaignsPauseRun502 = ExternalServiceError;
+const CampaignsPauseRun504 = GatewayTimeoutError;
+const CampaignsListRecipientsPathParams = /* @__PURE__ */ Schema.Struct({
+	id: CampaignId,
+	runId: CampaignRunId
+});
+const CampaignsListRecipientsQuery = /* @__PURE__ */ Schema.Struct({
+	status: Schema.optionalKey(Schema.Union([Schema.Union([
+		Schema.Literal("pending"),
+		Schema.Literal("dispatching"),
+		Schema.Literal("dispatched"),
+		Schema.Literal("failed"),
+		Schema.Literal("skipped")
+	]), Schema.Null])),
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null]))
+});
+const CampaignsListRecipients200 = CampaignRecipientPage;
+const CampaignsListRecipients401 = UnauthorizedError;
+const CampaignsListRecipients403 = ForbiddenError;
+const CampaignsListRecipients404 = ResourceNotFoundError;
+const CampaignsListRecipients422 = ValidationError;
+const CampaignsListRecipients500 = InternalError;
+const CampaignsListRecipients504 = GatewayTimeoutError;
+const CampaignsResumeRunPathParams = /* @__PURE__ */ Schema.Struct({
+	id: CampaignId,
+	runId: CampaignRunId
+});
+const CampaignsResumeRun200 = CampaignRunAction;
+const CampaignsResumeRun401 = UnauthorizedError;
+const CampaignsResumeRun403 = ForbiddenError;
+const CampaignsResumeRun404 = ResourceNotFoundError;
+const CampaignsResumeRun409 = ConflictError;
+const CampaignsResumeRun422 = ValidationError;
+const CampaignsResumeRun500 = InternalError;
+const CampaignsResumeRun502 = ExternalServiceError;
+const CampaignsResumeRun504 = GatewayTimeoutError;
+var CampaignsGroup = class extends HttpApiGroup.make("Campaigns").add(HttpApiEndpoint.get("campaignsList", "/v1/campaigns", {
+	query: CampaignsListQuery,
+	success: CampaignsList200,
+	error: [
+		CampaignsList401.pipe(HttpApiSchema.status(401)),
+		CampaignsList403.pipe(HttpApiSchema.status(403)),
+		CampaignsList422.pipe(HttpApiSchema.status(422)),
+		CampaignsList500,
+		CampaignsList504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "campaigns.list").annotate(OpenApi.Summary, "List campaigns").annotate(OpenApi.Description, "Returns the organization's campaigns, newest first, optionally filtered by status. Each row carries `series`, the last 14 days of daily email sends the campaign produced, oldest first. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page."), HttpApiEndpoint.post("campaignsCreate", "/v1/campaigns", {
+	payload: CampaignsCreateRequestJson,
+	success: CampaignsCreate201.pipe(HttpApiSchema.status(201)),
+	error: [
+		CampaignsCreate401.pipe(HttpApiSchema.status(401)),
+		CampaignsCreate403.pipe(HttpApiSchema.status(403)),
+		CampaignsCreate422.pipe(HttpApiSchema.status(422)),
+		CampaignsCreate500,
+		CampaignsCreate504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "campaigns.create").annotate(OpenApi.Summary, "Create a campaign").annotate(OpenApi.Description, "Creates an email campaign draft for the given audience and content, returning the created campaign."), HttpApiEndpoint.get("campaignsGet", "/v1/campaigns/:id", {
+	params: CampaignsGetPathParams,
+	success: CampaignsGet200,
+	error: [
+		CampaignsGet401.pipe(HttpApiSchema.status(401)),
+		CampaignsGet403.pipe(HttpApiSchema.status(403)),
+		CampaignsGet404.pipe(HttpApiSchema.status(404)),
+		CampaignsGet422.pipe(HttpApiSchema.status(422)),
+		CampaignsGet500,
+		CampaignsGet504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "campaigns.get").annotate(OpenApi.Summary, "Get a campaign").annotate(OpenApi.Description, "Returns a single campaign, including its content, audience, and policy, by its identifier."), HttpApiEndpoint.patch("campaignsUpdate", "/v1/campaigns/:id", {
+	params: CampaignsUpdatePathParams,
+	payload: CampaignsUpdateRequestJson,
+	success: CampaignsUpdate200,
+	error: [
+		CampaignsUpdate401.pipe(HttpApiSchema.status(401)),
+		CampaignsUpdate403.pipe(HttpApiSchema.status(403)),
+		CampaignsUpdate404.pipe(HttpApiSchema.status(404)),
+		CampaignsUpdate409.pipe(HttpApiSchema.status(409)),
+		CampaignsUpdate422.pipe(HttpApiSchema.status(422)),
+		CampaignsUpdate500,
+		CampaignsUpdate504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "campaigns.update").annotate(OpenApi.Summary, "Update a campaign").annotate(OpenApi.Description, "Updates the name, content, audience, or policy of a campaign draft."), HttpApiEndpoint.post("campaignsArchive", "/v1/campaigns/:id/archive", {
+	params: CampaignsArchivePathParams,
+	success: CampaignsArchive200,
+	error: [
+		CampaignsArchive401.pipe(HttpApiSchema.status(401)),
+		CampaignsArchive403.pipe(HttpApiSchema.status(403)),
+		CampaignsArchive404.pipe(HttpApiSchema.status(404)),
+		CampaignsArchive409.pipe(HttpApiSchema.status(409)),
+		CampaignsArchive422.pipe(HttpApiSchema.status(422)),
+		CampaignsArchive500,
+		CampaignsArchive504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "campaigns.archive").annotate(OpenApi.Summary, "Archive a campaign").annotate(OpenApi.Description, "Archives a draft campaign so it can no longer be scheduled, returning the archived campaign."), HttpApiEndpoint.get("campaignsListRuns", "/v1/campaigns/:id/runs", {
+	params: CampaignsListRunsPathParams,
+	query: CampaignsListRunsQuery,
+	success: CampaignsListRuns200,
+	error: [
+		CampaignsListRuns401.pipe(HttpApiSchema.status(401)),
+		CampaignsListRuns403.pipe(HttpApiSchema.status(403)),
+		CampaignsListRuns404.pipe(HttpApiSchema.status(404)),
+		CampaignsListRuns422.pipe(HttpApiSchema.status(422)),
+		CampaignsListRuns500,
+		CampaignsListRuns504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "campaigns.listRuns").annotate(OpenApi.Summary, "List campaign runs").annotate(OpenApi.Description, "Returns a campaign's runs, newest first, optionally filtered by status. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page."), HttpApiEndpoint.post("campaignsScheduleRun", "/v1/campaigns/:id/runs", {
+	params: CampaignsScheduleRunPathParams,
+	payload: CampaignsScheduleRunRequestJson,
+	success: CampaignsScheduleRun201.pipe(HttpApiSchema.status(201)),
+	error: [
+		CampaignsScheduleRun401.pipe(HttpApiSchema.status(401)),
+		CampaignsScheduleRun403.pipe(HttpApiSchema.status(403)),
+		CampaignsScheduleRun404.pipe(HttpApiSchema.status(404)),
+		CampaignsScheduleRun409.pipe(HttpApiSchema.status(409)),
+		CampaignsScheduleRun422.pipe(HttpApiSchema.status(422)),
+		CampaignsScheduleRun500,
+		CampaignsScheduleRun502.pipe(HttpApiSchema.status(502)),
+		CampaignsScheduleRun503.pipe(HttpApiSchema.status(503)),
+		CampaignsScheduleRun504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "campaigns.scheduleRun").annotate(OpenApi.Summary, "Schedule a campaign run").annotate(OpenApi.Description, "Schedules an email campaign run at the absolute ISO-8601 instant in scheduledFor, or immediately when omitted. The optional idempotencyKey is scoped to the organization and replays return the original run. An email campaign must carry the brand footer: it is refused with CampaignFooterRequiredError when its footer is off and its template renders no BrandFooter, and with BrandAddressRequiredError when a brand that signs it off has no postal address."), HttpApiEndpoint.get("campaignsGetRun", "/v1/campaigns/:id/runs/:runId", {
+	params: CampaignsGetRunPathParams,
+	success: CampaignsGetRun200,
+	error: [
+		CampaignsGetRun401.pipe(HttpApiSchema.status(401)),
+		CampaignsGetRun403.pipe(HttpApiSchema.status(403)),
+		CampaignsGetRun404.pipe(HttpApiSchema.status(404)),
+		CampaignsGetRun422.pipe(HttpApiSchema.status(422)),
+		CampaignsGetRun500,
+		CampaignsGetRun504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "campaigns.getRun").annotate(OpenApi.Summary, "Get a campaign run").annotate(OpenApi.Description, "Returns a single run of a campaign by its identifier."), HttpApiEndpoint.post("campaignsCancelRun", "/v1/campaigns/:id/runs/:runId/cancel", {
+	params: CampaignsCancelRunPathParams,
+	success: CampaignsCancelRun200,
+	error: [
+		CampaignsCancelRun401.pipe(HttpApiSchema.status(401)),
+		CampaignsCancelRun403.pipe(HttpApiSchema.status(403)),
+		CampaignsCancelRun404.pipe(HttpApiSchema.status(404)),
+		CampaignsCancelRun409.pipe(HttpApiSchema.status(409)),
+		CampaignsCancelRun422.pipe(HttpApiSchema.status(422)),
+		CampaignsCancelRun500,
+		CampaignsCancelRun502.pipe(HttpApiSchema.status(502)),
+		CampaignsCancelRun504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "campaigns.cancelRun").annotate(OpenApi.Summary, "Cancel a campaign run").annotate(OpenApi.Description, "Best-effort cancellation: pending recipients are skipped, while deliveries already handed off for sending may finish. Returns the updated run."), HttpApiEndpoint.post("campaignsPauseRun", "/v1/campaigns/:id/runs/:runId/pause", {
+	params: CampaignsPauseRunPathParams,
+	success: CampaignsPauseRun200,
+	error: [
+		CampaignsPauseRun401.pipe(HttpApiSchema.status(401)),
+		CampaignsPauseRun403.pipe(HttpApiSchema.status(403)),
+		CampaignsPauseRun404.pipe(HttpApiSchema.status(404)),
+		CampaignsPauseRun409.pipe(HttpApiSchema.status(409)),
+		CampaignsPauseRun422.pipe(HttpApiSchema.status(422)),
+		CampaignsPauseRun500,
+		CampaignsPauseRun502.pipe(HttpApiSchema.status(502)),
+		CampaignsPauseRun504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "campaigns.pauseRun").annotate(OpenApi.Summary, "Pause a campaign run").annotate(OpenApi.Description, "Pauses an in-progress campaign run and returns the updated run."), HttpApiEndpoint.get("campaignsListRecipients", "/v1/campaigns/:id/runs/:runId/recipients", {
+	params: CampaignsListRecipientsPathParams,
+	query: CampaignsListRecipientsQuery,
+	success: CampaignsListRecipients200,
+	error: [
+		CampaignsListRecipients401.pipe(HttpApiSchema.status(401)),
+		CampaignsListRecipients403.pipe(HttpApiSchema.status(403)),
+		CampaignsListRecipients404.pipe(HttpApiSchema.status(404)),
+		CampaignsListRecipients422.pipe(HttpApiSchema.status(422)),
+		CampaignsListRecipients500,
+		CampaignsListRecipients504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "campaigns.listRecipients").annotate(OpenApi.Summary, "List campaign recipients").annotate(OpenApi.Description, "Returns a campaign run's recipients in the order the run admitted them, optionally filtered by status. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page."), HttpApiEndpoint.post("campaignsResumeRun", "/v1/campaigns/:id/runs/:runId/resume", {
+	params: CampaignsResumeRunPathParams,
+	success: CampaignsResumeRun200,
+	error: [
+		CampaignsResumeRun401.pipe(HttpApiSchema.status(401)),
+		CampaignsResumeRun403.pipe(HttpApiSchema.status(403)),
+		CampaignsResumeRun404.pipe(HttpApiSchema.status(404)),
+		CampaignsResumeRun409.pipe(HttpApiSchema.status(409)),
+		CampaignsResumeRun422.pipe(HttpApiSchema.status(422)),
+		CampaignsResumeRun500,
+		CampaignsResumeRun502.pipe(HttpApiSchema.status(502)),
+		CampaignsResumeRun504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "campaigns.resumeRun").annotate(OpenApi.Summary, "Resume a campaign run").annotate(OpenApi.Description, "Resumes a paused campaign run and returns the updated run.")).annotate(OpenApi.Description, "Campaign drafts and scheduled campaign runs") {};
+//#endregion
+//#region src/effect/campaigns.ts
+var campaigns_exports = /* @__PURE__ */ __exportAll({
+	archive: () => archive,
+	cancelRun: () => cancelRun,
+	create: () => create,
+	get: () => get,
+	getRun: () => getRun,
+	list: () => list,
+	listRecipients: () => listRecipients,
+	listRuns: () => listRuns,
+	pauseRun: () => pauseRun,
+	resumeRun: () => resumeRun,
+	scheduleRun: () => scheduleRun,
+	update: () => update
+});
+const make = forGroup(CampaignsGroup);
+const list = make("campaignsList");
+const create = make("campaignsCreate");
+const get = make("campaignsGet");
+const archive = make("campaignsArchive");
+const update = make("campaignsUpdate");
+const listRuns = make("campaignsListRuns");
+const scheduleRun = make("campaignsScheduleRun");
+const getRun = make("campaignsGetRun");
+const pauseRun = make("campaignsPauseRun");
+const resumeRun = make("campaignsResumeRun");
+const cancelRun = make("campaignsCancelRun");
+const listRecipients = make("campaignsListRecipients");
+//#endregion
+export { get as a, listRecipients as c, resumeRun as d, scheduleRun as f, create as i, listRuns as l, campaigns_exports as n, getRun as o, update as p, cancelRun as r, list as s, archive as t, pauseRun as u };
+
+//# sourceMappingURL=campaigns-DZlz1E9E.js.map