samva 0.16.0 → 0.18.0

package/dist/effect/generated/extensions.js

@@ -0,0 +1,203 @@
+import { ApiKeySecurityMiddleware, ConflictError, Cursor, ExtensionId, ExtensionVersionId, ExtensionVersionRef, ForbiddenError, GatewayTimeoutError, InternalError, ResourceNotFoundError, UnauthorizedError, ValidationError } from "./shared.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
+export { Extension, ExtensionBundle, ExtensionPage, ExtensionVersion, ExtensionVersionPage, ExtensionVersionSummary, ExtensionsGet200, ExtensionsGet401, ExtensionsGet403, ExtensionsGet404, ExtensionsGet422, ExtensionsGet500, ExtensionsGet504, ExtensionsGetPathParams, ExtensionsGetVersion200, ExtensionsGetVersion401, ExtensionsGetVersion403, ExtensionsGetVersion404, ExtensionsGetVersion422, ExtensionsGetVersion500, ExtensionsGetVersion504, ExtensionsGetVersionPathParams, ExtensionsGroup, ExtensionsList200, ExtensionsList401, ExtensionsList403, ExtensionsList404, ExtensionsList422, ExtensionsList500, ExtensionsList504, ExtensionsListQuery, ExtensionsListVersions200, ExtensionsListVersions401, ExtensionsListVersions403, ExtensionsListVersions404, ExtensionsListVersions422, ExtensionsListVersions500, ExtensionsListVersions504, ExtensionsListVersionsPathParams, ExtensionsListVersionsQuery, ExtensionsPublish201, ExtensionsPublish401, ExtensionsPublish403, ExtensionsPublish404, ExtensionsPublish409, ExtensionsPublish422, ExtensionsPublish500, ExtensionsPublish504, ExtensionsPublishRequestJson, PublishExtensionVersionResponse };
+
+//# sourceMappingURL=extensions.js.map

package/dist/effect/generated/feedback.d.ts

@@ -0,0 +1,116 @@
+import type * as EffectBrand from "effect/Brand";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+import * as Schema from "effect/Schema";
+import { ApiKeySecurityMiddleware, FeedbackContext, ForbiddenError, GatewayTimeoutError, InternalError, UnauthorizedError, ValidationError } from "./shared";
+export type FeedbackId = string & EffectBrand.Brand<"FeedbackId">;
+export declare const FeedbackId: Schema.brand<Schema.String, "FeedbackId">;
+export type FeedbackReceipt = {
+    readonly id: FeedbackId;
+    readonly createdAt: string;
+};
+export declare const FeedbackReceipt: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "FeedbackId">;
+    readonly createdAt: Schema.String;
+}>;
+export type FeedbackSendRequestJson = {
+    readonly message: string;
+    readonly category?: "bug" | "confusing" | "missing" | "other" | null;
+    readonly context?: FeedbackContext | null;
+};
+export declare const FeedbackSendRequestJson: Schema.Struct<{
+    readonly message: Schema.String;
+    readonly category: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"bug">, Schema.Literal<"confusing">, Schema.Literal<"missing">, Schema.Literal<"other">]>, Schema.Null]>>;
+    readonly context: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly operation: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly resourceId: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    }>, Schema.Null]>>;
+}>;
+export type FeedbackSend201 = FeedbackReceipt;
+export declare const FeedbackSend201: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "FeedbackId">;
+    readonly createdAt: Schema.String;
+}>;
+export type FeedbackSend401 = UnauthorizedError;
+export declare const FeedbackSend401: typeof UnauthorizedError;
+export type FeedbackSend403 = ForbiddenError;
+export declare const FeedbackSend403: typeof ForbiddenError;
+export type FeedbackSend422 = ValidationError;
+export declare const FeedbackSend422: typeof ValidationError;
+export type FeedbackSend500 = InternalError;
+export declare const FeedbackSend500: typeof InternalError;
+export type FeedbackSend504 = GatewayTimeoutError;
+export declare const FeedbackSend504: typeof GatewayTimeoutError;
+declare const FeedbackGroup_base: HttpApiGroup.HttpApiGroup<"Feedback", HttpApiEndpoint.HttpApiEndpoint<"feedbackSend", "POST", "/v1/feedback", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly message: Schema.String;
+    readonly category: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"bug">, Schema.Literal<"confusing">, Schema.Literal<"missing">, Schema.Literal<"other">]>, Schema.Null]>>;
+    readonly context: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly operation: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly resourceId: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    }>, Schema.Null]>>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "FeedbackId">;
+    readonly createdAt: Schema.String;
+}>>, 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<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 FeedbackGroup extends FeedbackGroup_base {
+}
+export {};

package/dist/effect/generated/feedback.js

@@ -0,0 +1,43 @@
+import { ApiKeySecurityMiddleware, FeedbackContext, ForbiddenError, GatewayTimeoutError, InternalError, UnauthorizedError, ValidationError } from "./shared.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
+export { FeedbackGroup, FeedbackId, FeedbackReceipt, FeedbackSend201, FeedbackSend401, FeedbackSend403, FeedbackSend422, FeedbackSend500, FeedbackSend504, FeedbackSendRequestJson };
+
+//# sourceMappingURL=feedback.js.map

package/dist/effect/generated/index.d.ts

@@ -0,0 +1,61 @@
+import { HttpApi } from "effect/http-api";
+import { AnalyticsGroup } from "./analytics";
+import { APIKeysGroup } from "./api-keys";
+import { AttachmentsGroup } from "./attachments";
+import { BrandsGroup } from "./brands";
+import { CampaignsGroup } from "./campaigns";
+import { ContactEventsGroup } from "./contact-events";
+import { ContactGroupsGroup } from "./contact-groups";
+import { ContactsGroup } from "./contacts";
+import { ConversationsGroup } from "./conversations";
+import { CustomFieldsGroup } from "./custom-fields";
+import { EmailGroup } from "./email";
+import { EventsGroup } from "./events";
+import { ExtensionInstallationsGroup } from "./extension-installations";
+import { ExtensionsGroup } from "./extensions";
+import { FeedbackGroup } from "./feedback";
+import { JourneysGroup } from "./journeys";
+import { MailboxesGroup } from "./mailboxes";
+import { MediaGroup } from "./media";
+import { MessagesGroup } from "./messages";
+import { NamespacesGroup } from "./namespaces";
+import { OperationsGroup } from "./operations";
+import { OrganizationsGroup } from "./organizations";
+import { ScheduledMessagesGroup } from "./scheduled-messages";
+import { SubscriptionsGroup } from "./subscriptions";
+import { TemplatesGroup } from "./templates";
+import { UnsubscribeGroupsGroup } from "./unsubscribe-groups";
+import { WebhooksGroup } from "./webhooks";
+import { WhoamiGroup } from "./whoami";
+export * from "./shared";
+export * from "./analytics";
+export * from "./api-keys";
+export * from "./attachments";
+export * from "./brands";
+export * from "./campaigns";
+export * from "./contact-groups";
+export * from "./contacts";
+export * from "./contact-events";
+export * from "./conversations";
+export * from "./custom-fields";
+export * from "./email";
+export * from "./events";
+export * from "./extension-installations";
+export * from "./extensions";
+export * from "./feedback";
+export * from "./journeys";
+export * from "./mailboxes";
+export * from "./media";
+export * from "./messages";
+export * from "./scheduled-messages";
+export * from "./namespaces";
+export * from "./operations";
+export * from "./organizations";
+export * from "./subscriptions";
+export * from "./templates";
+export * from "./unsubscribe-groups";
+export * from "./webhooks";
+export * from "./whoami";
+declare const SamvaApi_base: HttpApi.HttpApi<"SamvaApi", typeof AnalyticsGroup | typeof APIKeysGroup | typeof AttachmentsGroup | typeof BrandsGroup | typeof CampaignsGroup | typeof ContactEventsGroup | typeof ContactGroupsGroup | typeof ContactsGroup | typeof ConversationsGroup | typeof CustomFieldsGroup | typeof EmailGroup | typeof EventsGroup | typeof ExtensionInstallationsGroup | typeof ExtensionsGroup | typeof FeedbackGroup | typeof JourneysGroup | typeof MailboxesGroup | typeof MediaGroup | typeof MessagesGroup | typeof NamespacesGroup | typeof OperationsGroup | typeof OrganizationsGroup | typeof ScheduledMessagesGroup | typeof SubscriptionsGroup | typeof TemplatesGroup | typeof UnsubscribeGroupsGroup | typeof WebhooksGroup | typeof WhoamiGroup>;
+export declare class SamvaApi extends SamvaApi_base {
+}