samva 0.16.0 → 0.17.0

package/dist/extensions-BKyNQLvu.js

@@ -0,0 +1,220 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { B as ExtensionId, D as Cursor, H as ExtensionVersionRef, Jt as UnauthorizedError, K as ForbiddenError, Lt as ResourceNotFoundError, V as ExtensionVersionId, 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/extensions.ts
+const ExtensionBundle = /* @__PURE__ */ Schema.Struct({
+	sha256: Schema.String,
+	sizeBytes: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" }))
+}).annotate({ identifier: "ExtensionBundle" });
+const ExtensionVersion = /* @__PURE__ */ Schema.Struct({
+	id: ExtensionVersionId,
+	version: Schema.String,
+	runtime: Schema.Union([Schema.Literal("hosted"), Schema.Literal("webhook")]),
+	bundle: Schema.Union([ExtensionBundle, Schema.Null]),
+	publishedAt: Schema.String,
+	manifest: Schema.Struct({
+		name: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z][a-z0-9-]{1,62}[a-z0-9]$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z][a-z0-9-]{1,62}[a-z0-9]$" })),
+		displayName: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(80).annotate({ expected: "a string with at most 80 code points" })).check(Schema.isMaxLength(80).annotate({ expected: "a value with a length of at most 80" })),
+		description: Schema.optionalKey(Schema.Union([Schema.String.check(Schema.isMaxCodePoints(500).annotate({ expected: "a string with at most 500 code points" })).check(Schema.isMaxLength(500).annotate({ expected: "a value with a length of at most 500" })), Schema.Null])),
+		version: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\d{1,6}\\.\\d{1,6}\\.\\d{1,6}(?:-[0-9A-Za-z.-]{1,64})?$", "u")).annotate({ expected: "a string matching the RegExp ^\\d{1,6}\\.\\d{1,6}\\.\\d{1,6}(?:-[0-9A-Za-z.-]{1,64})?$" })),
+		runtime: Schema.Union([Schema.Literal("hosted"), Schema.Literal("webhook")]),
+		events: Schema.Array(Schema.Union([
+			Schema.Literal("mailbox.message.received"),
+			Schema.Literal("mailbox.message.sent"),
+			Schema.Literal("mailbox.action.pending_approval"),
+			Schema.Literal("mailbox.message.quarantined"),
+			Schema.Literal("mailbox.message.released"),
+			Schema.Literal("mailbox.message.discarded")
+		])).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+		permissions: Schema.Array(Schema.Union([
+			Schema.Literal("read"),
+			Schema.Literal("update"),
+			Schema.Literal("send"),
+			Schema.Literal("quarantine.read")
+		]))
+	})
+}).annotate({ identifier: "ExtensionVersion" });
+const ExtensionVersionSummary = /* @__PURE__ */ Schema.Struct({
+	id: ExtensionVersionId,
+	version: Schema.String,
+	runtime: Schema.Union([Schema.Literal("hosted"), Schema.Literal("webhook")]),
+	bundle: Schema.Union([ExtensionBundle, Schema.Null]),
+	publishedAt: Schema.String
+}).annotate({ identifier: "ExtensionVersionSummary" });
+const Extension = /* @__PURE__ */ Schema.Struct({
+	id: ExtensionId,
+	name: Schema.String,
+	displayName: Schema.String,
+	description: Schema.Union([Schema.String, Schema.Null]),
+	runtime: Schema.Union([Schema.Literal("hosted"), Schema.Literal("webhook")]),
+	latestVersion: ExtensionVersionRef,
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+}).annotate({ identifier: "Extension" });
+const ExtensionVersionPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(ExtensionVersionSummary),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "ExtensionVersionPage" });
+const ExtensionPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(Extension),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "ExtensionPage" });
+const PublishExtensionVersionResponse = /* @__PURE__ */ Schema.Struct({
+	extension: Extension,
+	version: ExtensionVersion
+}).annotate({ identifier: "PublishExtensionVersionResponse" });
+const ExtensionsListQuery = /* @__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 ExtensionsList200 = ExtensionPage;
+const ExtensionsList401 = UnauthorizedError;
+const ExtensionsList403 = ForbiddenError;
+const ExtensionsList404 = ResourceNotFoundError;
+const ExtensionsList422 = ValidationError;
+const ExtensionsList500 = InternalError;
+const ExtensionsList504 = GatewayTimeoutError;
+const ExtensionsPublishRequestJson = /* @__PURE__ */ Schema.Struct({
+	manifest: Schema.Struct({
+		name: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z][a-z0-9-]{1,62}[a-z0-9]$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z][a-z0-9-]{1,62}[a-z0-9]$" })),
+		displayName: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(80).annotate({ expected: "a string with at most 80 code points" })).check(Schema.isMaxLength(80).annotate({ expected: "a value with a length of at most 80" })),
+		description: Schema.optionalKey(Schema.Union([Schema.String.check(Schema.isMaxCodePoints(500).annotate({ expected: "a string with at most 500 code points" })).check(Schema.isMaxLength(500).annotate({ expected: "a value with a length of at most 500" })), Schema.Null])),
+		version: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\d{1,6}\\.\\d{1,6}\\.\\d{1,6}(?:-[0-9A-Za-z.-]{1,64})?$", "u")).annotate({ expected: "a string matching the RegExp ^\\d{1,6}\\.\\d{1,6}\\.\\d{1,6}(?:-[0-9A-Za-z.-]{1,64})?$" })),
+		runtime: Schema.Union([Schema.Literal("hosted"), Schema.Literal("webhook")]),
+		events: Schema.Array(Schema.Union([
+			Schema.Literal("mailbox.message.received"),
+			Schema.Literal("mailbox.message.sent"),
+			Schema.Literal("mailbox.action.pending_approval"),
+			Schema.Literal("mailbox.message.quarantined"),
+			Schema.Literal("mailbox.message.released"),
+			Schema.Literal("mailbox.message.discarded")
+		])).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+		permissions: Schema.Array(Schema.Union([
+			Schema.Literal("read"),
+			Schema.Literal("update"),
+			Schema.Literal("send"),
+			Schema.Literal("quarantine.read")
+		]))
+	}),
+	bundle: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+});
+const ExtensionsPublish201 = PublishExtensionVersionResponse;
+const ExtensionsPublish401 = UnauthorizedError;
+const ExtensionsPublish403 = ForbiddenError;
+const ExtensionsPublish404 = ResourceNotFoundError;
+const ExtensionsPublish409 = ConflictError;
+const ExtensionsPublish422 = ValidationError;
+const ExtensionsPublish500 = InternalError;
+const ExtensionsPublish504 = GatewayTimeoutError;
+const ExtensionsGetPathParams = /* @__PURE__ */ Schema.Struct({ id: Schema.String.annotate({ description: "The extension's id (`ext_…`) or its name." }).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(64).annotate({ expected: "a string with at most 64 code points" })).check(Schema.isMaxLength(64).annotate({ expected: "a value with a length of at most 64" })) });
+const ExtensionsGet200 = Extension;
+const ExtensionsGet401 = UnauthorizedError;
+const ExtensionsGet403 = ForbiddenError;
+const ExtensionsGet404 = ResourceNotFoundError;
+const ExtensionsGet422 = ValidationError;
+const ExtensionsGet500 = InternalError;
+const ExtensionsGet504 = GatewayTimeoutError;
+const ExtensionsListVersionsPathParams = /* @__PURE__ */ Schema.Struct({ id: Schema.String.annotate({ description: "The extension's id (`ext_…`) or its name." }).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(64).annotate({ expected: "a string with at most 64 code points" })).check(Schema.isMaxLength(64).annotate({ expected: "a value with a length of at most 64" })) });
+const ExtensionsListVersionsQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null]))
+});
+const ExtensionsListVersions200 = ExtensionVersionPage;
+const ExtensionsListVersions401 = UnauthorizedError;
+const ExtensionsListVersions403 = ForbiddenError;
+const ExtensionsListVersions404 = ResourceNotFoundError;
+const ExtensionsListVersions422 = ValidationError;
+const ExtensionsListVersions500 = InternalError;
+const ExtensionsListVersions504 = GatewayTimeoutError;
+const ExtensionsGetVersionPathParams = /* @__PURE__ */ Schema.Struct({
+	id: Schema.String.annotate({ description: "The extension's id (`ext_…`) or its name." }).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(64).annotate({ expected: "a string with at most 64 code points" })).check(Schema.isMaxLength(64).annotate({ expected: "a value with a length of at most 64" })),
+	versionId: Schema.String.annotate({ description: "The version's id (`extver_…`) or its version string, such as `1.0.0`." }).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(85).annotate({ expected: "a string with at most 85 code points" })).check(Schema.isMaxLength(85).annotate({ expected: "a value with a length of at most 85" }))
+});
+const ExtensionsGetVersion200 = ExtensionVersion;
+const ExtensionsGetVersion401 = UnauthorizedError;
+const ExtensionsGetVersion403 = ForbiddenError;
+const ExtensionsGetVersion404 = ResourceNotFoundError;
+const ExtensionsGetVersion422 = ValidationError;
+const ExtensionsGetVersion500 = InternalError;
+const ExtensionsGetVersion504 = GatewayTimeoutError;
+var ExtensionsGroup = class extends HttpApiGroup.make("Extensions").add(HttpApiEndpoint.get("extensionsList", "/v1/extensions", {
+	query: ExtensionsListQuery,
+	success: ExtensionsList200,
+	error: [
+		ExtensionsList401.pipe(HttpApiSchema.status(401)),
+		ExtensionsList403.pipe(HttpApiSchema.status(403)),
+		ExtensionsList404.pipe(HttpApiSchema.status(404)),
+		ExtensionsList422.pipe(HttpApiSchema.status(422)),
+		ExtensionsList500,
+		ExtensionsList504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "extensions.list").annotate(OpenApi.Summary, "List extensions").annotate(OpenApi.Description, "Returns the organization's published extensions with their latest version, newest first, filterable by creation time (`after`, `before`). Pass `nextCursor` back as `cursor` for the next page; it is null on the last page."), HttpApiEndpoint.post("extensionsPublish", "/v1/extensions", {
+	payload: ExtensionsPublishRequestJson,
+	success: ExtensionsPublish201.pipe(HttpApiSchema.status(201)),
+	error: [
+		ExtensionsPublish401.pipe(HttpApiSchema.status(401)),
+		ExtensionsPublish403.pipe(HttpApiSchema.status(403)),
+		ExtensionsPublish404.pipe(HttpApiSchema.status(404)),
+		ExtensionsPublish409.pipe(HttpApiSchema.status(409)),
+		ExtensionsPublish422.pipe(HttpApiSchema.status(422)),
+		ExtensionsPublish500,
+		ExtensionsPublish504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "extensions.publish").annotate(OpenApi.Summary, "Publish an extension version").annotate(OpenApi.Description, "Publishes one version from its manifest and returns it with status 201, creating the extension named by the manifest on its first version. A hosted manifest carries its bundle. Publishing a version again with the same manifest and bundle returns it; a different one conflicts, so bump the manifest's version. Only a person can publish, not an API key."), HttpApiEndpoint.get("extensionsGet", "/v1/extensions/:id", {
+	params: ExtensionsGetPathParams,
+	success: ExtensionsGet200,
+	error: [
+		ExtensionsGet401.pipe(HttpApiSchema.status(401)),
+		ExtensionsGet403.pipe(HttpApiSchema.status(403)),
+		ExtensionsGet404.pipe(HttpApiSchema.status(404)),
+		ExtensionsGet422.pipe(HttpApiSchema.status(422)),
+		ExtensionsGet500,
+		ExtensionsGet504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "extensions.get").annotate(OpenApi.Summary, "Get an extension").annotate(OpenApi.Description, "Returns one extension by its id or name. Its versions are `GET /v1/extensions/{id}/versions`."), HttpApiEndpoint.get("extensionsListVersions", "/v1/extensions/:id/versions", {
+	params: ExtensionsListVersionsPathParams,
+	query: ExtensionsListVersionsQuery,
+	success: ExtensionsListVersions200,
+	error: [
+		ExtensionsListVersions401.pipe(HttpApiSchema.status(401)),
+		ExtensionsListVersions403.pipe(HttpApiSchema.status(403)),
+		ExtensionsListVersions404.pipe(HttpApiSchema.status(404)),
+		ExtensionsListVersions422.pipe(HttpApiSchema.status(422)),
+		ExtensionsListVersions500,
+		ExtensionsListVersions504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "extensions.listVersions").annotate(OpenApi.Summary, "List an extension's versions").annotate(OpenApi.Description, "Returns summaries of an extension's published versions, newest first. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page. Read a version's manifest with `GET /v1/extensions/{id}/versions/{versionId}`."), HttpApiEndpoint.get("extensionsGetVersion", "/v1/extensions/:id/versions/:versionId", {
+	params: ExtensionsGetVersionPathParams,
+	success: ExtensionsGetVersion200,
+	error: [
+		ExtensionsGetVersion401.pipe(HttpApiSchema.status(401)),
+		ExtensionsGetVersion403.pipe(HttpApiSchema.status(403)),
+		ExtensionsGetVersion404.pipe(HttpApiSchema.status(404)),
+		ExtensionsGetVersion422.pipe(HttpApiSchema.status(422)),
+		ExtensionsGetVersion500,
+		ExtensionsGetVersion504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "extensions.getVersion").annotate(OpenApi.Summary, "Get an extension version").annotate(OpenApi.Description, "Returns one version, by its id or version string, with the manifest it was published with.")).annotate(OpenApi.Description, "Code that receives mailbox events and acts through the mailbox API") {};
+//#endregion
+//#region src/effect/extensions.ts
+var extensions_exports = /* @__PURE__ */ __exportAll({
+	get: () => get,
+	getVersion: () => getVersion,
+	list: () => list,
+	listVersions: () => listVersions,
+	publish: () => publish
+});
+const make = forGroup(ExtensionsGroup);
+const list = make("extensionsList");
+const publish = make("extensionsPublish");
+const get = make("extensionsGet");
+const listVersions = make("extensionsListVersions");
+const getVersion = make("extensionsGetVersion");
+//#endregion
+export { listVersions as a, list as i, get as n, publish as o, getVersion as r, extensions_exports as t };
+
+//# sourceMappingURL=extensions-BKyNQLvu.js.map

package/dist/feedback-Bpa09JOS.js

@@ -0,0 +1,52 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { Jt as UnauthorizedError, K as ForbiddenError, Rt as SendFeedback, W as FeedbackContext, Y as InternalError, en as ValidationError, q as GatewayTimeoutError, s as ApiKeySecurityMiddleware } from "./client-DOzUrdTE.js";
+import { n as forGroup } from "./operation-n_IYgNVK.js";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/feedback.ts
+const FeedbackId = /* @__PURE__ */ Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^fdbk_[0-9a-hjkmnp-tv-z]{16,24}$", "u")).annotate({
+	expected: "a string matching the RegExp ^fdbk_[0-9a-hjkmnp-tv-z]{16,24}$",
+	identifier: "FeedbackId"
+})).pipe(Schema.brand("FeedbackId"));
+const FeedbackReceipt = /* @__PURE__ */ Schema.Struct({
+	id: FeedbackId,
+	createdAt: Schema.String
+}).annotate({ identifier: "FeedbackReceipt" });
+const FeedbackSendRequestJson = /* @__PURE__ */ Schema.Struct({
+	message: Schema.String.annotate({ description: "What happened and what you expected, in plain language (at most 4000 characters)." }).check(Schema.isMaxCodePoints(4e3).annotate({ expected: "a string with at most 4000 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("\\S", "u")).annotate({ expected: "a string matching the RegExp \\S" })).check(Schema.isMaxLength(4e3).annotate({ expected: "a value with a length of at most 4000" })),
+	category: Schema.optionalKey(Schema.Union([Schema.Union([
+		Schema.Literal("bug"),
+		Schema.Literal("confusing"),
+		Schema.Literal("missing"),
+		Schema.Literal("other")
+	]).annotate({ description: "`bug`: the API behaved wrongly. `confusing`: a response, error, or doc was hard to act on. `missing`: a capability or field you needed does not exist. `other`: anything else." }), Schema.Null])),
+	context: Schema.optionalKey(Schema.Union([FeedbackContext, Schema.Null]))
+});
+const FeedbackSend201 = FeedbackReceipt;
+const FeedbackSend401 = UnauthorizedError;
+const FeedbackSend403 = ForbiddenError;
+const FeedbackSend422 = ValidationError;
+const FeedbackSend500 = InternalError;
+const FeedbackSend504 = GatewayTimeoutError;
+var FeedbackGroup = class extends HttpApiGroup.make("Feedback").add(HttpApiEndpoint.post("feedbackSend", "/v1/feedback", {
+	payload: FeedbackSendRequestJson,
+	success: FeedbackSend201.pipe(HttpApiSchema.status(201)),
+	error: [
+		FeedbackSend401.pipe(HttpApiSchema.status(401)),
+		FeedbackSend403.pipe(HttpApiSchema.status(403)),
+		FeedbackSend422.pipe(HttpApiSchema.status(422)),
+		FeedbackSend500,
+		FeedbackSend504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "feedback.send").annotate(OpenApi.Summary, "Send feedback").annotate(OpenApi.Description, "Tells Samva what was confusing, broken, or missing in the API. Programs and coding agents can call it the moment something goes wrong, naming the operation and resource involved. Samva's team reads every report; the answer is a receipt, not a reply.")).annotate(OpenApi.Description, "Reports to Samva about the API itself.") {};
+//#endregion
+//#region src/effect/feedback.ts
+var feedback_exports = /* @__PURE__ */ __exportAll({
+	SendPayload: () => SendFeedback,
+	send: () => send
+});
+const send = forGroup(FeedbackGroup)("feedbackSend");
+//#endregion
+export { send as n, feedback_exports as t };
+
+//# sourceMappingURL=feedback-Bpa09JOS.js.map

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as MediaUploadError } from "./inline-attachments-Cegg6tTF.js";
-import { C as SenderNotReadyError, E as fromApiError, S as SamvaTransportError, T as ValidationError, _ as OnboardingReviewRequiredError, a as CampaignFooterRequiredError, b as ResourceNotFoundError, c as EmailChannelError, d as ForbiddenError, f as GatewayTimeoutError, g as MailboxSendRefusedError, h as MailboxSendConflictError, i as BrandAddressRequiredError, l as ExternalServiceError, m as MailboxChannelUnsupportedError, n as AnalyticsQueryError, o as ConflictError, p as InternalError, r as BillingProviderError, s as DeliveryUnavailableError, t as createClient, u as FlagDisabledError, v as PaymentRequiredError, w as UnauthorizedError, x as SamvaApiError, y as RateLimitedError } from "./promises-KrA2nSLg.js";
+import { t as MediaUploadError } from "./inline-attachments-Bi1hDltp.js";
+import { C as SenderNotReadyError, E as fromApiError, S as SamvaTransportError, T as ValidationError, _ as OnboardingReviewRequiredError, a as CampaignFooterRequiredError, b as ResourceNotFoundError, c as EmailChannelError, d as ForbiddenError, f as GatewayTimeoutError, g as MailboxSendRefusedError, h as MailboxSendConflictError, i as BrandAddressRequiredError, l as ExternalServiceError, m as MailboxChannelUnsupportedError, n as AnalyticsQueryError, o as ConflictError, p as InternalError, r as BillingProviderError, s as DeliveryUnavailableError, t as createClient, u as FlagDisabledError, v as PaymentRequiredError, w as UnauthorizedError, x as SamvaApiError, y as RateLimitedError } from "./promises---Kbh-7z.js";
 import { n as MailboxEventStreamError, t as MailboxEventStream } from "./mailbox-events-VKR4f3qq.js";
 export { AnalyticsQueryError, BillingProviderError, BrandAddressRequiredError, CampaignFooterRequiredError, ConflictError, DeliveryUnavailableError, EmailChannelError, ExternalServiceError, FlagDisabledError, ForbiddenError, GatewayTimeoutError, InternalError, MailboxChannelUnsupportedError, MailboxEventStream, MailboxEventStreamError, MailboxSendConflictError, MailboxSendRefusedError, MediaUploadError, OnboardingReviewRequiredError, PaymentRequiredError, RateLimitedError, ResourceNotFoundError, SamvaApiError, SamvaTransportError, SenderNotReadyError, UnauthorizedError, ValidationError, createClient, fromApiError };

package/dist/{inline-attachments-Cegg6tTF.js → inline-attachments-Bi1hDltp.js}

@@ -1,6 +1,6 @@
 //#endregion
 //#region src/client-attribution.ts
-const SDK_VERSION = "0.16.0";
+const SDK_VERSION = "0.17.0";
 const CLIENT_ATTRIBUTION_HEADER = "x-samva-client";
 const clientAttribution = (surface) => `${surface}/${SDK_VERSION}`;
 /** A failed upload of an attachment's bytes to its presigned media URL. */
@@ -118,4 +118,4 @@ const withUploadedAttachments = (payload, uploaded) => {
 //#endregion
 export { withUploadedAttachments as a, uploadContentType as i, mediaCreateBody as n, CLIENT_ATTRIBUTION_HEADER as o, planInlineUploads as r, clientAttribution as s, MediaUploadError as t };
 
-//# sourceMappingURL=inline-attachments-Cegg6tTF.js.map
+//# sourceMappingURL=inline-attachments-Bi1hDltp.js.map