samva 0.16.0 → 0.18.0

package/dist/effect/generated/campaigns.js

@@ -0,0 +1,491 @@
+import { AbsoluteInstant } from "../runtime.js";
+import { ApiKeySecurityMiddleware, BrandAddressRequiredError, CampaignFooterRequiredError, ConflictError, ContactGroupId, ContactId, ConversationId, Cursor, EmailContent, EmailDispatchContent, EmailDomainId, ExternalServiceError, FlagDisabledError, ForbiddenError, GatewayTimeoutError, InternalError, JsonValue, ResourceNotFoundError, SenderNotReadyError, SendsSeries, UnauthorizedError, UnsubscribeId, ValidationError } from "./shared.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
+export { Campaign, CampaignAudience, CampaignContent, CampaignContentInput, CampaignContentMetadata, CampaignConversationRef, CampaignDefinitionSummary, CampaignId, CampaignLatestRun, CampaignListItem, CampaignPage, CampaignPolicy, CampaignRecipientId, CampaignRecipientPage, CampaignRun, CampaignRunAction, CampaignRunId, CampaignRunPage, CampaignsArchive200, CampaignsArchive401, CampaignsArchive403, CampaignsArchive404, CampaignsArchive409, CampaignsArchive422, CampaignsArchive500, CampaignsArchive504, CampaignsArchivePathParams, CampaignsCancelRun200, CampaignsCancelRun401, CampaignsCancelRun403, CampaignsCancelRun404, CampaignsCancelRun409, CampaignsCancelRun422, CampaignsCancelRun500, CampaignsCancelRun502, CampaignsCancelRun504, CampaignsCancelRunPathParams, CampaignsCreate201, CampaignsCreate401, CampaignsCreate403, CampaignsCreate422, CampaignsCreate500, CampaignsCreate504, CampaignsCreateRequestJson, CampaignsGet200, CampaignsGet401, CampaignsGet403, CampaignsGet404, CampaignsGet422, CampaignsGet500, CampaignsGet504, CampaignsGetPathParams, CampaignsGetRun200, CampaignsGetRun401, CampaignsGetRun403, CampaignsGetRun404, CampaignsGetRun422, CampaignsGetRun500, CampaignsGetRun504, CampaignsGetRunPathParams, CampaignsGroup, CampaignsList200, CampaignsList401, CampaignsList403, CampaignsList422, CampaignsList500, CampaignsList504, CampaignsListQuery, CampaignsListRecipients200, CampaignsListRecipients401, CampaignsListRecipients403, CampaignsListRecipients404, CampaignsListRecipients422, CampaignsListRecipients500, CampaignsListRecipients504, CampaignsListRecipientsPathParams, CampaignsListRecipientsQuery, CampaignsListRuns200, CampaignsListRuns401, CampaignsListRuns403, CampaignsListRuns404, CampaignsListRuns422, CampaignsListRuns500, CampaignsListRuns504, CampaignsListRunsPathParams, CampaignsListRunsQuery, CampaignsPauseRun200, CampaignsPauseRun401, CampaignsPauseRun403, CampaignsPauseRun404, CampaignsPauseRun409, CampaignsPauseRun422, CampaignsPauseRun500, CampaignsPauseRun502, CampaignsPauseRun504, CampaignsPauseRunPathParams, CampaignsResumeRun200, CampaignsResumeRun401, CampaignsResumeRun403, CampaignsResumeRun404, CampaignsResumeRun409, CampaignsResumeRun422, CampaignsResumeRun500, CampaignsResumeRun502, CampaignsResumeRun504, CampaignsResumeRunPathParams, CampaignsScheduleRun201, CampaignsScheduleRun401, CampaignsScheduleRun403, CampaignsScheduleRun404, CampaignsScheduleRun409, CampaignsScheduleRun422, CampaignsScheduleRun500, CampaignsScheduleRun502, CampaignsScheduleRun503, CampaignsScheduleRun504, CampaignsScheduleRunPathParams, CampaignsScheduleRunRequestJson, CampaignsUpdate200, CampaignsUpdate401, CampaignsUpdate403, CampaignsUpdate404, CampaignsUpdate409, CampaignsUpdate422, CampaignsUpdate500, CampaignsUpdate504, CampaignsUpdatePathParams, CampaignsUpdateRequestJson };
+
+//# sourceMappingURL=campaigns.js.map

package/dist/effect/generated/contact-events.d.ts

@@ -0,0 +1,158 @@
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+import * as Schema from "effect/Schema";
+import { ApiKeySecurityMiddleware, ContactEvent, ContactId, Cursor, ForbiddenError, GatewayTimeoutError, InternalError, ResourceNotFoundError, UnauthorizedError, ValidationError } from "./shared";
+export type ContactEventPage = {
+    readonly items: ReadonlyArray<ContactEvent>;
+    readonly nextCursor: string | null;
+};
+export declare const ContactEventPage: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly contactId: Schema.brand<Schema.String, "ContactId">;
+        readonly name: Schema.String;
+        readonly source: Schema.Union<readonly [Schema.Literal<"api">, Schema.Literal<"samva">]>;
+        readonly properties: Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<import("./shared").JsonValue, import("./shared").JsonValue, never, never>>>;
+        readonly occurredAt: Schema.String;
+        readonly recordedAt: Schema.String;
+    }>>;
+    readonly nextCursor: Schema.Union<readonly [Schema.String, Schema.Null]>;
+}>;
+export type ContactEventsListEventsPathParams = {
+    readonly id: ContactId;
+};
+export declare const ContactEventsListEventsPathParams: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "ContactId">;
+}>;
+export type ContactEventsListEventsQuery = {
+    readonly limit?: string | null;
+    readonly cursor?: Cursor | null;
+};
+export declare const ContactEventsListEventsQuery: Schema.Struct<{
+    readonly limit: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly cursor: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>;
+export type ContactEventsListEvents200 = ContactEventPage;
+export declare const ContactEventsListEvents200: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly contactId: Schema.brand<Schema.String, "ContactId">;
+        readonly name: Schema.String;
+        readonly source: Schema.Union<readonly [Schema.Literal<"api">, Schema.Literal<"samva">]>;
+        readonly properties: Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<import("./shared").JsonValue, import("./shared").JsonValue, never, never>>>;
+        readonly occurredAt: Schema.String;
+        readonly recordedAt: Schema.String;
+    }>>;
+    readonly nextCursor: Schema.Union<readonly [Schema.String, Schema.Null]>;
+}>;
+export type ContactEventsListEvents401 = UnauthorizedError;
+export declare const ContactEventsListEvents401: typeof UnauthorizedError;
+export type ContactEventsListEvents403 = ForbiddenError;
+export declare const ContactEventsListEvents403: typeof ForbiddenError;
+export type ContactEventsListEvents404 = ResourceNotFoundError;
+export declare const ContactEventsListEvents404: typeof ResourceNotFoundError;
+export type ContactEventsListEvents422 = ValidationError;
+export declare const ContactEventsListEvents422: typeof ValidationError;
+export type ContactEventsListEvents500 = InternalError;
+export declare const ContactEventsListEvents500: typeof InternalError;
+export type ContactEventsListEvents504 = GatewayTimeoutError;
+export declare const ContactEventsListEvents504: typeof GatewayTimeoutError;
+declare const ContactEventsGroup_base: HttpApiGroup.HttpApiGroup<"Contact events", HttpApiEndpoint.HttpApiEndpoint<"contactEventsListEvents", "GET", "/v1/contacts/:id/events", Schema.toCodecStringTree<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "ContactId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    readonly limit: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly cursor: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly contactId: Schema.brand<Schema.String, "ContactId">;
+        readonly name: Schema.String;
+        readonly source: Schema.Union<readonly [Schema.Literal<"api">, Schema.Literal<"samva">]>;
+        readonly properties: Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<import("./shared").JsonValue, import("./shared").JsonValue, never, never>>>;
+        readonly occurredAt: Schema.String;
+        readonly recordedAt: Schema.String;
+    }>>;
+    readonly nextCursor: Schema.Union<readonly [Schema.String, Schema.Null]>;
+}>>, Schema.toCodecJson<Schema.decodeTo<Schema.declareConstructor<ForbiddenError, {
+    readonly _tag: "ForbiddenError";
+    readonly message: string;
+}, readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"ForbiddenError">;
+    readonly message: Schema.String;
+}>], {
+    readonly _tag: "ForbiddenError";
+    readonly message: string;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"ForbiddenError">;
+    readonly message: Schema.String;
+}>, never, never> | Schema.decodeTo<Schema.declareConstructor<GatewayTimeoutError, {
+    readonly _tag: "GatewayTimeoutError";
+    readonly message: string;
+    readonly retryAfterSeconds: number;
+}, readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"GatewayTimeoutError">;
+    readonly message: Schema.String;
+    readonly retryAfterSeconds: Schema.Finite;
+}>], {
+    readonly _tag: "GatewayTimeoutError";
+    readonly message: string;
+    readonly retryAfterSeconds: number;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"GatewayTimeoutError">;
+    readonly message: Schema.String;
+    readonly retryAfterSeconds: Schema.Finite;
+}>, never, never> | Schema.decodeTo<Schema.declareConstructor<ResourceNotFoundError, {
+    readonly _tag: "ResourceNotFoundError";
+    readonly resource: string;
+    readonly id: string;
+    readonly message: string;
+}, readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"ResourceNotFoundError">;
+    readonly resource: Schema.String;
+    readonly id: Schema.String;
+    readonly message: Schema.String;
+}>], {
+    readonly _tag: "ResourceNotFoundError";
+    readonly resource: string;
+    readonly id: string;
+    readonly message: string;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"ResourceNotFoundError">;
+    readonly resource: Schema.String;
+    readonly id: Schema.String;
+    readonly message: Schema.String;
+}>, never, never> | Schema.decodeTo<Schema.declareConstructor<UnauthorizedError, {
+    readonly _tag: "UnauthorizedError";
+    readonly message: string;
+}, readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"UnauthorizedError">;
+    readonly message: Schema.String;
+}>], {
+    readonly _tag: "UnauthorizedError";
+    readonly message: string;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"UnauthorizedError">;
+    readonly message: Schema.String;
+}>, never, never> | Schema.decodeTo<Schema.declareConstructor<ValidationError, {
+    readonly _tag: "ValidationError";
+    readonly message: string;
+    readonly fields?: {
+        readonly [x: string]: readonly string[];
+    } | null;
+}, readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"ValidationError">;
+    readonly message: Schema.String;
+    readonly fields: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.$Array<Schema.String>>, Schema.Null]>>;
+}>], {
+    readonly _tag: "ValidationError";
+    readonly message: string;
+    readonly fields?: {
+        readonly [x: string]: readonly string[];
+    } | null;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"ValidationError">;
+    readonly message: Schema.String;
+    readonly fields: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.$Array<Schema.String>>, Schema.Null]>>;
+}>, never, never> | typeof InternalError>, ApiKeySecurityMiddleware, never>, false>;
+export declare class ContactEventsGroup extends ContactEventsGroup_base {
+}
+export {};