samva 0.16.0 → 0.17.0

package/dist/media-VrrtNnft.js

@@ -0,0 +1,181 @@
+import { Ht as SuccessResponse, Jt as UnauthorizedError, K as ForbiddenError, Lt as ResourceNotFoundError, Mt as OrganizationId, St as MediaId, Y as InternalError, en as ValidationError, q as GatewayTimeoutError, s as ApiKeySecurityMiddleware } from "./client-DOzUrdTE.js";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/media.ts
+const MediaUploadInstruction = /* @__PURE__ */ Schema.Struct({
+	url: Schema.String,
+	method: Schema.Literal("PUT"),
+	headers: Schema.Record(Schema.String, Schema.String),
+	expiresAt: Schema.String
+}).annotate({ identifier: "MediaUploadInstruction" });
+const MediaDownloadUrl = /* @__PURE__ */ Schema.Struct({
+	url: Schema.String,
+	expiresAt: Schema.String
+}).annotate({ identifier: "MediaDownloadUrl" });
+const Media = /* @__PURE__ */ Schema.Struct({
+	id: MediaId,
+	organizationId: OrganizationId,
+	status: Schema.Union([
+		Schema.Literal("pending"),
+		Schema.Literal("uploading"),
+		Schema.Literal("processing"),
+		Schema.Literal("ready"),
+		Schema.Literal("failed"),
+		Schema.Literal("deleted")
+	]),
+	filename: Schema.String,
+	contentType: Schema.String,
+	sizeBytes: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	width: Schema.Union([Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })).check(Schema.isGreaterThan(0).annotate({ expected: "a value greater than 0" })), Schema.Null]),
+	height: Schema.Union([Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })).check(Schema.isGreaterThan(0).annotate({ expected: "a value greater than 0" })), 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]),
+	purpose: Schema.Union([
+		Schema.Literal("attachment"),
+		Schema.Literal("avatar"),
+		Schema.Literal("review_evidence")
+	]),
+	checksumSha256: Schema.Union([Schema.String, Schema.Null]),
+	expiresAt: Schema.Union([Schema.String, Schema.Null]),
+	createdAt: Schema.String,
+	confirmedAt: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "Media" });
+const CreatedMedia = /* @__PURE__ */ Schema.Struct({
+	id: MediaId,
+	organizationId: OrganizationId,
+	status: Schema.Union([
+		Schema.Literal("pending"),
+		Schema.Literal("uploading"),
+		Schema.Literal("processing"),
+		Schema.Literal("ready"),
+		Schema.Literal("failed"),
+		Schema.Literal("deleted")
+	]),
+	filename: Schema.String,
+	contentType: Schema.String,
+	sizeBytes: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	width: Schema.Union([Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })).check(Schema.isGreaterThan(0).annotate({ expected: "a value greater than 0" })), Schema.Null]),
+	height: Schema.Union([Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })).check(Schema.isGreaterThan(0).annotate({ expected: "a value greater than 0" })), 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]),
+	purpose: Schema.Union([
+		Schema.Literal("attachment"),
+		Schema.Literal("avatar"),
+		Schema.Literal("review_evidence")
+	]),
+	checksumSha256: Schema.Union([Schema.String, Schema.Null]),
+	expiresAt: Schema.Union([Schema.String, Schema.Null]),
+	createdAt: Schema.String,
+	confirmedAt: Schema.Union([Schema.String, Schema.Null]),
+	upload: MediaUploadInstruction
+}).annotate({ identifier: "CreatedMedia" });
+const CompletedMedia = /* @__PURE__ */ Schema.Struct({
+	media: Media,
+	downloadUrl: Schema.String
+}).annotate({ identifier: "CompletedMedia" });
+const MediaCreateRequestJson = /* @__PURE__ */ Schema.Struct({
+	filename: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" })),
+	contentType: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(127).annotate({ expected: "a string with at most 127 code points" })).check(Schema.isMaxLength(127).annotate({ expected: "a value with a length of at most 127" })),
+	sizeBytes: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isLessThanOrEqualTo(26214400).annotate({ expected: "a value less than or equal to 26214400" })).check(Schema.isGreaterThan(0).annotate({ expected: "a value greater than 0" })),
+	purpose: Schema.Union([
+		Schema.Literal("attachment"),
+		Schema.Literal("avatar"),
+		Schema.Literal("review_evidence")
+	]),
+	checksumSha256: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+});
+const MediaCreate201 = CreatedMedia;
+const MediaCreate401 = UnauthorizedError;
+const MediaCreate403 = ForbiddenError;
+const MediaCreate422 = ValidationError;
+const MediaCreate500 = InternalError;
+const MediaCreate504 = GatewayTimeoutError;
+const MediaGetByIdPathParams = /* @__PURE__ */ Schema.Struct({ id: MediaId });
+const MediaGetById200 = Media;
+const MediaGetById401 = UnauthorizedError;
+const MediaGetById403 = ForbiddenError;
+const MediaGetById404 = ResourceNotFoundError;
+const MediaGetById422 = ValidationError;
+const MediaGetById500 = InternalError;
+const MediaGetById504 = GatewayTimeoutError;
+const MediaRemovePathParams = /* @__PURE__ */ Schema.Struct({ id: MediaId });
+const MediaRemove200 = SuccessResponse;
+const MediaRemove401 = UnauthorizedError;
+const MediaRemove403 = ForbiddenError;
+const MediaRemove404 = ResourceNotFoundError;
+const MediaRemove422 = ValidationError;
+const MediaRemove500 = InternalError;
+const MediaRemove504 = GatewayTimeoutError;
+const MediaCompletePathParams = /* @__PURE__ */ Schema.Struct({ id: MediaId });
+const MediaComplete200 = CompletedMedia;
+const MediaComplete401 = UnauthorizedError;
+const MediaComplete403 = ForbiddenError;
+const MediaComplete404 = ResourceNotFoundError;
+const MediaComplete422 = ValidationError;
+const MediaComplete500 = InternalError;
+const MediaComplete504 = GatewayTimeoutError;
+const MediaDownloadUrlPathParams = /* @__PURE__ */ Schema.Struct({ id: MediaId });
+const MediaDownloadUrl200 = MediaDownloadUrl;
+const MediaDownloadUrl401 = UnauthorizedError;
+const MediaDownloadUrl403 = ForbiddenError;
+const MediaDownloadUrl404 = ResourceNotFoundError;
+const MediaDownloadUrl422 = ValidationError;
+const MediaDownloadUrl500 = InternalError;
+const MediaDownloadUrl504 = GatewayTimeoutError;
+var MediaGroup = class extends HttpApiGroup.make("Media").add(HttpApiEndpoint.post("mediaCreate", "/v1/media", {
+	payload: MediaCreateRequestJson,
+	success: MediaCreate201.pipe(HttpApiSchema.status(201)),
+	error: [
+		MediaCreate401.pipe(HttpApiSchema.status(401)),
+		MediaCreate403.pipe(HttpApiSchema.status(403)),
+		MediaCreate422.pipe(HttpApiSchema.status(422)),
+		MediaCreate500,
+		MediaCreate504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "media.create").annotate(OpenApi.Summary, "Create a media object").annotate(OpenApi.Description, "Creates the media object in the pending state and returns it with the upload instruction — URL, method, and headers — for putting its bytes into storage. Requires `messages:create`, or `email:send` for `attachment` media."), HttpApiEndpoint.get("mediaGetById", "/v1/media/:id", {
+	params: MediaGetByIdPathParams,
+	success: MediaGetById200,
+	error: [
+		MediaGetById401.pipe(HttpApiSchema.status(401)),
+		MediaGetById403.pipe(HttpApiSchema.status(403)),
+		MediaGetById404.pipe(HttpApiSchema.status(404)),
+		MediaGetById422.pipe(HttpApiSchema.status(422)),
+		MediaGetById500,
+		MediaGetById504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "media.getById").annotate(OpenApi.Summary, "Get a media object").annotate(OpenApi.Description, "Returns the media object's metadata, including status, dimensions, and confirmation timestamps."), HttpApiEndpoint.delete("mediaRemove", "/v1/media/:id", {
+	params: MediaRemovePathParams,
+	success: MediaRemove200,
+	error: [
+		MediaRemove401.pipe(HttpApiSchema.status(401)),
+		MediaRemove403.pipe(HttpApiSchema.status(403)),
+		MediaRemove404.pipe(HttpApiSchema.status(404)),
+		MediaRemove422.pipe(HttpApiSchema.status(422)),
+		MediaRemove500,
+		MediaRemove504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "media.remove").annotate(OpenApi.Summary, "Delete a media object").annotate(OpenApi.Description, "Deletes a pending media object and the bytes stored for it. Fails if the media object is already ready."), HttpApiEndpoint.post("mediaComplete", "/v1/media/:id/complete", {
+	params: MediaCompletePathParams,
+	success: MediaComplete200,
+	error: [
+		MediaComplete401.pipe(HttpApiSchema.status(401)),
+		MediaComplete403.pipe(HttpApiSchema.status(403)),
+		MediaComplete404.pipe(HttpApiSchema.status(404)),
+		MediaComplete422.pipe(HttpApiSchema.status(422)),
+		MediaComplete500,
+		MediaComplete504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "media.complete").annotate(OpenApi.Summary, "Complete a media upload").annotate(OpenApi.Description, "Verifies the uploaded object exists in storage, marks the media object ready, and returns it with a download URL. Requires the permission that creating the media object did."), HttpApiEndpoint.get("mediaDownloadUrl", "/v1/media/:id/url", {
+	params: MediaDownloadUrlPathParams,
+	success: MediaDownloadUrl200,
+	error: [
+		MediaDownloadUrl401.pipe(HttpApiSchema.status(401)),
+		MediaDownloadUrl403.pipe(HttpApiSchema.status(403)),
+		MediaDownloadUrl404.pipe(HttpApiSchema.status(404)),
+		MediaDownloadUrl422.pipe(HttpApiSchema.status(422)),
+		MediaDownloadUrl500,
+		MediaDownloadUrl504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "media.downloadUrl").annotate(OpenApi.Summary, "Get a media download URL").annotate(OpenApi.Description, "Generates a presigned, time-limited download URL for a ready media object.")).annotate(OpenApi.Description, "Media objects and the presigned uploads that fill them") {};
+//#endregion
+export { MediaGroup as t };
+
+//# sourceMappingURL=media-VrrtNnft.js.map

package/dist/namespaces-CcvEbG-y.js

@@ -0,0 +1,152 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { D as Cursor, Dt as NamespaceMetadata, Et as NamespaceId, Ht as SuccessResponse, Jt as UnauthorizedError, K as ForbiddenError, Lt as ResourceNotFoundError, Y as InternalError, en as ValidationError, m as ConflictError, 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/namespaces.ts
+const NamespaceSummary = /* @__PURE__ */ Schema.Struct({
+	id: NamespaceId,
+	name: Schema.String,
+	createdAt: Schema.String
+}).annotate({ identifier: "NamespaceSummary" });
+const Namespace = /* @__PURE__ */ Schema.Struct({
+	id: NamespaceId,
+	name: Schema.String,
+	createdAt: Schema.String,
+	metadata: NamespaceMetadata,
+	updatedAt: Schema.String
+}).annotate({ identifier: "Namespace" });
+const NamespacePage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(NamespaceSummary),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "NamespacePage" });
+const NamespacesListQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null])),
+	after: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	before: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+});
+const NamespacesList200 = NamespacePage;
+const NamespacesList401 = UnauthorizedError;
+const NamespacesList403 = ForbiddenError;
+const NamespacesList422 = ValidationError;
+const NamespacesList500 = InternalError;
+const NamespacesList504 = GatewayTimeoutError;
+const NamespacesCreateRequestJson = /* @__PURE__ */ Schema.Struct({
+	name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\S[\\s\\S]*\\S$|^\\S$|^$", "u")).annotate({ expected: "a string matching the RegExp ^\\S[\\s\\S]*\\S$|^\\S$|^$" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+	metadata: Schema.optionalKey(Schema.Union([NamespaceMetadata, Schema.Null]))
+});
+const NamespacesCreate201 = Namespace;
+const NamespacesCreate401 = UnauthorizedError;
+const NamespacesCreate403 = ForbiddenError;
+const NamespacesCreate409 = ConflictError;
+const NamespacesCreate422 = ValidationError;
+const NamespacesCreate500 = InternalError;
+const NamespacesCreate504 = GatewayTimeoutError;
+const NamespacesGetPathParams = /* @__PURE__ */ Schema.Struct({ id: NamespaceId });
+const NamespacesGet200 = Namespace;
+const NamespacesGet401 = UnauthorizedError;
+const NamespacesGet403 = ForbiddenError;
+const NamespacesGet404 = ResourceNotFoundError;
+const NamespacesGet422 = ValidationError;
+const NamespacesGet500 = InternalError;
+const NamespacesGet504 = GatewayTimeoutError;
+const NamespacesRemovePathParams = /* @__PURE__ */ Schema.Struct({ id: NamespaceId });
+const NamespacesRemove200 = SuccessResponse;
+const NamespacesRemove401 = UnauthorizedError;
+const NamespacesRemove403 = ForbiddenError;
+const NamespacesRemove404 = ResourceNotFoundError;
+const NamespacesRemove409 = ConflictError;
+const NamespacesRemove422 = ValidationError;
+const NamespacesRemove500 = InternalError;
+const NamespacesRemove504 = GatewayTimeoutError;
+const NamespacesUpdatePathParams = /* @__PURE__ */ Schema.Struct({ id: NamespaceId });
+const NamespacesUpdateRequestJson = /* @__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(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\S[\\s\\S]*\\S$|^\\S$|^$", "u")).annotate({ expected: "a string matching the RegExp ^\\S[\\s\\S]*\\S$|^\\S$|^$" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })), Schema.Null])),
+	metadata: Schema.optionalKey(Schema.Union([Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Null])), Schema.Null]))
+});
+const NamespacesUpdate200 = Namespace;
+const NamespacesUpdate401 = UnauthorizedError;
+const NamespacesUpdate403 = ForbiddenError;
+const NamespacesUpdate404 = ResourceNotFoundError;
+const NamespacesUpdate409 = ConflictError;
+const NamespacesUpdate422 = ValidationError;
+const NamespacesUpdate500 = InternalError;
+const NamespacesUpdate504 = GatewayTimeoutError;
+var NamespacesGroup = class extends HttpApiGroup.make("Namespaces").add(HttpApiEndpoint.get("namespacesList", "/v1/namespaces", {
+	query: NamespacesListQuery,
+	success: NamespacesList200,
+	error: [
+		NamespacesList401.pipe(HttpApiSchema.status(401)),
+		NamespacesList403.pipe(HttpApiSchema.status(403)),
+		NamespacesList422.pipe(HttpApiSchema.status(422)),
+		NamespacesList500,
+		NamespacesList504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "namespaces.list").annotate(OpenApi.Summary, "List namespaces").annotate(OpenApi.Description, "Returns namespace summaries, newest first, filterable by creation time (`after`, `before`). Pass `nextCursor` back as `cursor` for the next page; it is null on the last page. Read a namespace's metadata with `GET /v1/namespaces/{id}`."), HttpApiEndpoint.post("namespacesCreate", "/v1/namespaces", {
+	payload: NamespacesCreateRequestJson,
+	success: NamespacesCreate201.pipe(HttpApiSchema.status(201)),
+	error: [
+		NamespacesCreate401.pipe(HttpApiSchema.status(401)),
+		NamespacesCreate403.pipe(HttpApiSchema.status(403)),
+		NamespacesCreate409.pipe(HttpApiSchema.status(409)),
+		NamespacesCreate422.pipe(HttpApiSchema.status(422)),
+		NamespacesCreate500,
+		NamespacesCreate504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "namespaces.create").annotate(OpenApi.Summary, "Create a namespace").annotate(OpenApi.Description, "Creates a namespace with status 201. Names are unique within the organization; a duplicate conflicts."), HttpApiEndpoint.get("namespacesGet", "/v1/namespaces/:id", {
+	params: NamespacesGetPathParams,
+	success: NamespacesGet200,
+	error: [
+		NamespacesGet401.pipe(HttpApiSchema.status(401)),
+		NamespacesGet403.pipe(HttpApiSchema.status(403)),
+		NamespacesGet404.pipe(HttpApiSchema.status(404)),
+		NamespacesGet422.pipe(HttpApiSchema.status(422)),
+		NamespacesGet500,
+		NamespacesGet504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "namespaces.get").annotate(OpenApi.Summary, "Get a namespace").annotate(OpenApi.Description, "Returns one namespace."), HttpApiEndpoint.delete("namespacesRemove", "/v1/namespaces/:id", {
+	params: NamespacesRemovePathParams,
+	success: NamespacesRemove200,
+	error: [
+		NamespacesRemove401.pipe(HttpApiSchema.status(401)),
+		NamespacesRemove403.pipe(HttpApiSchema.status(403)),
+		NamespacesRemove404.pipe(HttpApiSchema.status(404)),
+		NamespacesRemove409.pipe(HttpApiSchema.status(409)),
+		NamespacesRemove422.pipe(HttpApiSchema.status(422)),
+		NamespacesRemove500,
+		NamespacesRemove504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "namespaces.remove").annotate(OpenApi.Summary, "Delete a namespace").annotate(OpenApi.Description, "Deletes an empty namespace. A namespace that still holds mailboxes, API keys, or webhook endpoints conflicts: remove them first."), HttpApiEndpoint.patch("namespacesUpdate", "/v1/namespaces/:id", {
+	params: NamespacesUpdatePathParams,
+	payload: NamespacesUpdateRequestJson,
+	success: NamespacesUpdate200,
+	error: [
+		NamespacesUpdate401.pipe(HttpApiSchema.status(401)),
+		NamespacesUpdate403.pipe(HttpApiSchema.status(403)),
+		NamespacesUpdate404.pipe(HttpApiSchema.status(404)),
+		NamespacesUpdate409.pipe(HttpApiSchema.status(409)),
+		NamespacesUpdate422.pipe(HttpApiSchema.status(422)),
+		NamespacesUpdate500,
+		NamespacesUpdate504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "namespaces.update").annotate(OpenApi.Summary, "Update a namespace").annotate(OpenApi.Description, "Updates the fields you name and keeps the rest. `metadata` merges into the stored metadata by key, and a `null` value deletes that key.")).annotate(OpenApi.Description, "Sub-tenants that confine mailboxes and API keys inside an organization") {};
+//#endregion
+//#region src/effect/namespaces.ts
+var namespaces_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	get: () => get,
+	list: () => list,
+	remove: () => remove,
+	update: () => update
+});
+const make = forGroup(NamespacesGroup);
+const list = make("namespacesList");
+const create = make("namespacesCreate");
+const get = make("namespacesGet");
+const update = make("namespacesUpdate");
+const remove = make("namespacesRemove");
+//#endregion
+export { remove as a, namespaces_exports as i, get as n, update as o, list as r, create as t };
+
+//# sourceMappingURL=namespaces-CcvEbG-y.js.map

package/dist/{operation-BTXjPrwf.js → operation-n_IYgNVK.js}

@@ -1,7 +1,6 @@
-import { a as withUploadedAttachments, n as mediaCreateBody, r as planInlineUploads } from "./inline-attachments-Cegg6tTF.js";
-import { n as buildMessagesSendPayload, r as replyToEmailsPayload, t as buildEmailSendPayload } from "./normalize-B79uJIeb.js";
-import { k as SamvaApi, t as Service } from "./client-BMUew5Wp.js";
-import { generateIdempotencyKey, withRetry } from "./effect/retry.js";
+import { t as Service } from "./client-DOzUrdTE.js";
+import { y as SamvaOperations } from "./categories-CA4XIQAb.js";
+import { withRetry } from "./effect/retry.js";
 import { Effect, Option, Predicate, Stream } from "effect";
 //#region src/service-map.ts
 /** How each generated Effect operation is adapted to the Promise facade's direct input shape. */
@@ -359,6 +358,62 @@ const SDK_OPERATION_CALLS = {
 		kind: "pathPayload",
 		paths: ["id"]
 	},
+	journeysList: { kind: "params" },
+	journeysCreate: { kind: "payload" },
+	journeysGet: {
+		kind: "path",
+		paths: ["id"]
+	},
+	journeysUpdate: {
+		kind: "pathPayload",
+		paths: ["id"]
+	},
+	journeysRemove: {
+		kind: "path",
+		paths: ["id"]
+	},
+	journeysReplaceDraft: {
+		kind: "pathPayload",
+		paths: ["id"]
+	},
+	journeysPublish: {
+		kind: "pathPayload",
+		paths: ["id"]
+	},
+	journeysPause: {
+		kind: "path",
+		paths: ["id"]
+	},
+	journeysResume: {
+		kind: "path",
+		paths: ["id"]
+	},
+	journeysArchive: {
+		kind: "path",
+		paths: ["id"]
+	},
+	journeysGetVersion: {
+		kind: "path",
+		paths: ["id", "version"]
+	},
+	journeysStats: {
+		kind: "pathParams",
+		paths: ["id"]
+	},
+	journeysListRuns: {
+		kind: "pathParams",
+		paths: ["id"]
+	},
+	journeysGetRun: {
+		kind: "path",
+		paths: ["id", "runId"]
+	},
+	eventsCreate: { kind: "payload" },
+	eventsBatch: { kind: "payload" },
+	contactEventsListEvents: {
+		kind: "pathParams",
+		paths: ["id"]
+	},
 	contactsList: { kind: "params" },
 	contactsCreate: { kind: "payload" },
 	contactsFind: { kind: "payload" },
@@ -1031,31 +1086,7 @@ const streamCursorPages = (operation, input) => Stream.paginate(startCursorOf(in
 const streamCursorItems = (operation, input) => Stream.paginate(startCursorOf(input), (cursor) => fetchCursorPage(operation, input, cursor).pipe(Effect.map((result) => [result.items, Option.fromNullishOr(result.nextCursor)])));
 //#endregion
 //#region src/effect/internal/operation.ts
-const hasField = (node, name) => node?.propertySignatures?.some((property) => property.name === name) ?? false;
-const isCursorPaged = (success) => {
-	if (!(success instanceof Set)) return false;
-	for (const schema of success) for (const node of [
-		schema.ast,
-		schema.ast?.to,
-		schema.ast?.from
-	]) if (hasField(node, "items") && hasField(node, "nextCursor")) return true;
-	return false;
-};
-const paginatedOperations = () => {
-	const paginated = /* @__PURE__ */ new Set();
-	const groups = SamvaApi.groups;
-	for (const group of Object.values(groups)) for (const [name, endpoint] of Object.entries(group.endpoints)) if (isCursorPaged(endpoint.success)) paginated.add(name);
-	return paginated;
-};
-const PAGINATED_OPERATIONS = paginatedOperations();
 const READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
-const readOperations = () => {
-	const reads = /* @__PURE__ */ new Set();
-	const groups = SamvaApi.groups;
-	for (const group of Object.values(groups)) for (const [name, endpoint] of Object.entries(group.endpoints)) if (READ_METHODS.has(endpoint.method)) reads.add(name);
-	return reads;
-};
-const READ_OPERATIONS = readOperations();
 const MODULE_NAMES = {
 	analytics: "Analytics",
 	apiKeys: "ApiKeys",
@@ -1095,10 +1126,9 @@ const stripUndefined = (input) => {
 	if (Object.getPrototypeOf(input) !== Object.prototype) return input;
 	return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0).map(([key, value]) => [key, stripUndefined(value)]));
 };
-const rawOperation = (client, name) => client.operation(name);
 const adapt = (operationName, rawCall, input) => {
 	const descriptor = SDK_OPERATION_CALLS[operationName];
-	const call = READ_OPERATIONS.has(operationName) ? (request) => withRetry(rawCall(request)) : rawCall;
+	const call = READ_METHODS.has(SamvaOperations[operationName].method) ? (request) => withRetry(rawCall(request)) : rawCall;
 	if (descriptor.kind === "none") return call();
 	if (descriptor.kind === "params") return call({ query: stripUndefined(input) });
 	if (descriptor.kind === "payload") return call({ payload: stripUndefined(input) });
@@ -1139,10 +1169,20 @@ const adapt = (operationName, rawCall, input) => {
 	});
 };
 const isCursorPageEnvelope = (value) => Predicate.isObject(value) && Array.isArray(value.items) && (value.nextCursor === null || typeof value.nextCursor === "string");
-const make = (operationName) => {
-	const call = Effect.fn(traceName(operationName))((input) => Effect.flatMap(Service, (client) => adapt(operationName, rawOperation(client, operationName), input)));
+/**
+* Operation factory for one API group. Each domain module binds its own group, so importing it
+* loads that group's schemas and nothing else.
+*/
+const forGroup = (group) => (operationName) => {
+	if (SamvaOperations[operationName].group !== group.identifier) throw new Error(`${operationName} is not an endpoint of ${group.identifier}`);
+	return make(group, operationName);
+};
+/** Call one endpoint with an already-shaped request, outside the direct-operation adapter. */
+const callEndpoint = (group, name, request) => Effect.flatMap(Service, (client) => Effect.flatMap(client.endpoint(group, name), (call) => call(request)));
+const make = (group, operationName) => {
+	const call = Effect.fn(traceName(operationName))((input) => Effect.flatMap(Service, (client) => Effect.flatMap(client.endpoint(group, operationName), (rawCall) => adapt(operationName, rawCall, input))));
 	const operation = call;
-	if (PAGINATED_OPERATIONS.has(operationName)) {
+	if (SamvaOperations[operationName].paginated) {
 		const list = (input) => Effect.filterOrElse(call(input), isCursorPageEnvelope, () => Effect.die(/* @__PURE__ */ new Error(`${operationName} did not return a cursor page envelope`)));
 		Object.assign(operation, {
 			pages: (input) => streamCursorPages(list, input ?? {}),
@@ -1151,62 +1191,7 @@ const make = (operationName) => {
 	}
 	return operation;
 };
-/**
-* Inline attachment content over the API's request cap travels as media instead: the largest
-* attachments are uploaded (create, put to the presigned URL, complete) and replaced by their
-* `mediaId`. The returned payload is the one request every send attempt reuses, so nothing is
-* uploaded twice.
-*/
-const uploadOversizedAttachments = (client, payload) => Effect.gen(function* () {
-	const plan = planInlineUploads(payload);
-	if (plan.length === 0) return payload;
-	const uploaded = /* @__PURE__ */ new Map();
-	for (const upload of plan) {
-		const created = yield* rawOperation(client, "mediaCreate")({ payload: mediaCreateBody(upload) });
-		yield* client.putUpload({
-			filename: upload.filename,
-			mediaId: created.id,
-			url: created.upload.url,
-			method: created.upload.method,
-			headers: created.upload.headers,
-			bytes: upload.bytes
-		});
-		yield* rawOperation(client, "mediaComplete")({ params: { id: created.id } });
-		uploaded.set(upload.index, {
-			mediaId: created.id,
-			upload
-		});
-	}
-	return withUploadedAttachments(payload, uploaded);
-});
-const sendPayload = (payload, options) => Effect.gen(function* () {
-	const client = yield* Service;
-	const idempotencyKey = options?.idempotencyKey ?? (yield* generateIdempotencyKey);
-	const prepared = yield* uploadOversizedAttachments(client, payload);
-	return yield* withRetry(rawOperation(client, "messagesSend")({
-		payload: stripUndefined(prepared),
-		headers: { "idempotency-key": idempotencyKey }
-	}));
-});
-const sendMessage = Effect.fn("Messages.send")(function* (input, options) {
-	return yield* sendPayload(buildMessagesSendPayload(input), options);
-});
-const sendEmail = Effect.fn("Email.send")(function* (input, options) {
-	return yield* sendPayload(buildEmailSendPayload(input), options);
-});
-const addEmailSender = Effect.fn("Email.addSender")(function* (input, options) {
-	const client = yield* Service;
-	const idempotencyKey = options?.idempotencyKey ?? (yield* generateIdempotencyKey);
-	const { replyToEmails, ...sender } = input;
-	return yield* withRetry(rawOperation(client, "emailAddSender")({
-		headers: { "idempotency-key": idempotencyKey },
-		payload: stripUndefined({
-			...sender,
-			...replyToEmailsPayload(replyToEmails)
-		})
-	}));
-});
 //#endregion
-export { sendMessage as i, make as n, sendEmail as r, addEmailSender as t };
+export { forGroup as n, stripUndefined as r, callEndpoint as t };
 
-//# sourceMappingURL=operation-BTXjPrwf.js.map
+//# sourceMappingURL=operation-n_IYgNVK.js.map

package/dist/operations-CmB3FHwf.js

@@ -0,0 +1,93 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { At as OperationAccepted, D as Cursor, Jt as UnauthorizedError, K as ForbiddenError, Lt as ResourceNotFoundError, Y as InternalError, en as ValidationError, jt as OperationId, kt as Operation, m as ConflictError, 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/operations.ts
+const OperationPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(Operation),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "OperationPage" });
+const OperationsListQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null])),
+	kind: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Literal("email-domain-provisioning"), Schema.Literal("organization-deletion")]), Schema.Null])),
+	status: Schema.optionalKey(Schema.Union([Schema.Union([
+		Schema.Literal("pending"),
+		Schema.Literal("running"),
+		Schema.Literal("succeeded"),
+		Schema.Literal("failed")
+	]), Schema.Null]))
+});
+const OperationsList200 = OperationPage;
+const OperationsList401 = UnauthorizedError;
+const OperationsList403 = ForbiddenError;
+const OperationsList422 = ValidationError;
+const OperationsList500 = InternalError;
+const OperationsList504 = GatewayTimeoutError;
+const OperationsGetPathParams = /* @__PURE__ */ Schema.Struct({ id: OperationId });
+const OperationsGet200 = Operation;
+const OperationsGet401 = UnauthorizedError;
+const OperationsGet403 = ForbiddenError;
+const OperationsGet404 = ResourceNotFoundError;
+const OperationsGet422 = ValidationError;
+const OperationsGet500 = InternalError;
+const OperationsGet504 = GatewayTimeoutError;
+const OperationsRetryPathParams = /* @__PURE__ */ Schema.Struct({ id: OperationId });
+const OperationsRetry202 = OperationAccepted;
+const OperationsRetry401 = UnauthorizedError;
+const OperationsRetry403 = ForbiddenError;
+const OperationsRetry404 = ResourceNotFoundError;
+const OperationsRetry409 = ConflictError;
+const OperationsRetry422 = ValidationError;
+const OperationsRetry500 = InternalError;
+const OperationsRetry504 = GatewayTimeoutError;
+var OperationsGroup = class extends HttpApiGroup.make("Operations").add(HttpApiEndpoint.get("operationsList", "/v1/operations", {
+	query: OperationsListQuery,
+	success: OperationsList200,
+	error: [
+		OperationsList401.pipe(HttpApiSchema.status(401)),
+		OperationsList403.pipe(HttpApiSchema.status(403)),
+		OperationsList422.pipe(HttpApiSchema.status(422)),
+		OperationsList500,
+		OperationsList504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "operations.list").annotate(OpenApi.Summary, "List asynchronous operations").annotate(OpenApi.Description, "Lists asynchronous operations for the active organization, newest first. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page."), HttpApiEndpoint.get("operationsGet", "/v1/operations/:id", {
+	params: OperationsGetPathParams,
+	success: OperationsGet200,
+	error: [
+		OperationsGet401.pipe(HttpApiSchema.status(401)),
+		OperationsGet403.pipe(HttpApiSchema.status(403)),
+		OperationsGet404.pipe(HttpApiSchema.status(404)),
+		OperationsGet422.pipe(HttpApiSchema.status(422)),
+		OperationsGet500,
+		OperationsGet504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "operations.get").annotate(OpenApi.Summary, "Get an asynchronous operation").annotate(OpenApi.Description, "Returns one asynchronous operation from the active organization."), HttpApiEndpoint.post("operationsRetry", "/v1/operations/:id/retry", {
+	params: OperationsRetryPathParams,
+	success: OperationsRetry202.pipe(HttpApiSchema.status(202)),
+	error: [
+		OperationsRetry401.pipe(HttpApiSchema.status(401)),
+		OperationsRetry403.pipe(HttpApiSchema.status(403)),
+		OperationsRetry404.pipe(HttpApiSchema.status(404)),
+		OperationsRetry409.pipe(HttpApiSchema.status(409)),
+		OperationsRetry422.pipe(HttpApiSchema.status(422)),
+		OperationsRetry500,
+		OperationsRetry504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "operations.retry").annotate(OpenApi.Summary, "Retry an asynchronous operation").annotate(OpenApi.Description, "Retries a failed operation in place when its error is retryable. Retrying an organization deletion additionally requires `organization:delete`.")).annotate(OpenApi.Description, "Status of accepted asynchronous mutations") {};
+//#endregion
+//#region src/effect/operations.ts
+var operations_exports = /* @__PURE__ */ __exportAll({
+	get: () => get,
+	list: () => list,
+	retry: () => retry
+});
+const make = forGroup(OperationsGroup);
+const list = make("operationsList");
+const get = make("operationsGet");
+const retry = make("operationsRetry");
+//#endregion
+export { retry as i, list as n, operations_exports as r, get as t };
+
+//# sourceMappingURL=operations-CmB3FHwf.js.map