@buildinternet/releases-api-types 0.59.0 → 0.60.0

package/dist/schemas/collections.js

@@ -0,0 +1,320 @@
+import { z } from "zod";
+import { ImportanceScoreSchema, ReleaseCompositionSchema, ReleaseItemSchema } from "./shared.js";
+/**
+ * One org as it appears inside a collection's preview list or detail page.
+ * Joined through `organizations_public`, so soft-deleted / on_demand orgs
+ * never leak via a collection.
+ */
+export const CollectionMemberOrgSchema = z.object({
+    slug: z.string(),
+    name: z.string(),
+    domain: z.string().nullable(),
+    avatarUrl: z.string().nullable(),
+    /** GitHub handle from `org_accounts`; lets the avatar fall back to github.com/<handle>.png. */
+    githubHandle: z.string().nullable(),
+    description: z.string().nullable(),
+});
+/**
+ * Org context attached to a product member so the chip can render the parent
+ * org's avatar / handle. Subset of `CollectionMemberOrg` — description is
+ * intentionally omitted because the byline comes from the product itself.
+ */
+export const ProductParentOrgSchema = z.object({
+    slug: z.string(),
+    name: z.string(),
+    domain: z.string().nullable(),
+    avatarUrl: z.string().nullable(),
+    githubHandle: z.string().nullable(),
+});
+/**
+ * One product as it appears inside a collection. Carries the parent org block
+ * so the chip can render the org's avatar (products don't have their own).
+ */
+export const CollectionMemberProductSchema = z.object({
+    slug: z.string(),
+    name: z.string(),
+    description: z.string().nullable(),
+    org: ProductParentOrgSchema,
+});
+/**
+ * Mixed-kind member entry. `kind` discriminates: `org` carries the org block at
+ * the top level; `product` carries the product fields plus a `org` parent block.
+ * Used by `GET /v1/collections/:slug` (`members` field) and the new
+ * `previewMembers` on `GET /v1/collections`.
+ */
+export const CollectionMemberSchema = z.discriminatedUnion("kind", [
+    CollectionMemberOrgSchema.extend({ kind: z.literal("org") }),
+    CollectionMemberProductSchema.extend({ kind: z.literal("product") }),
+]);
+/**
+ * Row on `GET /v1/collections`. `previewMembers` (the new mixed-kind preview)
+ * is the first few visible members so the list page can render inline avatars
+ * without a second round trip. `previewOrgs` is the legacy org-only preview,
+ * retained for back-compat — clients should migrate to `previewMembers`.
+ */
+export const CollectionListItemSchema = z.object({
+    slug: z.string(),
+    name: z.string(),
+    description: z.string().nullable(),
+    memberCount: z.number().int().min(0),
+    /** Whether the collection is promoted on the homepage. Filterable via `?featured=1`. */
+    isFeatured: z.boolean(),
+    /** Mixed-kind preview (org + product). Cap matches `previewOrgs`. */
+    previewMembers: z.array(CollectionMemberSchema).optional(),
+    /** Legacy org-only preview. Populated with the org-kind subset of `previewMembers`. */
+    previewOrgs: z.array(CollectionMemberOrgSchema).optional(),
+});
+export const CollectionListResponseSchema = z.array(CollectionListItemSchema);
+/**
+ * Returned by `GET /v1/collections/:slug`.
+ *
+ * `members` is the mixed-kind canonical list. `orgs` is the legacy org-only
+ * field, populated with the org-kind subset of `members` for back-compat —
+ * new clients should consume `members`.
+ */
+export const CollectionDetailSchema = z.object({
+    slug: z.string(),
+    name: z.string(),
+    description: z.string().nullable(),
+    /** Whether the collection is promoted on the homepage. */
+    isFeatured: z.boolean(),
+    /** Per-collection enable toggle for the nightly daily-summary generation. */
+    dailySummaryEnabled: z.boolean(),
+    /** Whether the collection generates weekly digests (gates the email-subscribe toggle). */
+    weeklyDigestEnabled: z.boolean(),
+    members: z.array(CollectionMemberSchema),
+    /** @deprecated Use `members`. Org-only subset, kept for back-compat. */
+    orgs: z.array(CollectionMemberOrgSchema),
+});
+/**
+ * Cross-member release feed row on `GET /v1/collections/:slug/releases`. Same
+ * shape as `OrgReleaseItem` plus the origin `org` block (and optional
+ * `product`) so the web's release card can render it identically. `source.type`
+ * stays as `z.string()` because the SQL passes the column through unvalidated —
+ * tightening to the SourceType enum would break pass-through code.
+ */
+export const CollectionReleaseItemSchema = ReleaseItemSchema.extend({
+    id: z.string(),
+    source: z.object({ slug: z.string(), name: z.string(), type: z.string() }),
+    org: z.object({ slug: z.string(), name: z.string() }),
+    /**
+     * Product the release belongs to, if the source is bound to one. `null` for
+     * orgs without products or standalone sources. Optional on the wire so older
+     * workers mid-rollout (and hand-constructed test fixtures) don't trip the
+     * typecheck — clients should treat missing and `null` identically.
+     */
+    product: z.object({ slug: z.string(), name: z.string() }).nullable().optional(),
+    /**
+     * Server-resolved grouping identity — `COALESCE(product.slug, source.slug)` /
+     * `COALESCE(product.name, source.name)`. The web release feeds key and label
+     * SDK/package-cluster rollups on these instead of reconstructing
+     * `product ?? source` client-side. Optional on the wire: older workers omit
+     * them, so clients must fall back to deriving from `product ?? source`. Never
+     * null when present (`source` is always set). #1234
+     */
+    groupSlug: z.string().optional(),
+    groupName: z.string().optional(),
+});
+/** Cursor pagination shape matches `/v1/orgs/:slug/releases`. */
+export const CollectionFeedPaginationSchema = z.object({
+    nextCursor: z.string().nullable(),
+    limit: z.number().int().min(1),
+});
+export const CollectionReleasesResponseSchema = z.object({
+    releases: z.array(CollectionReleaseItemSchema),
+    pagination: CollectionFeedPaginationSchema,
+});
+/**
+ * Bare row returned by `POST /v1/collections` and `PATCH /v1/collections/:slug`.
+ * Mirrors the `collections` table columns (no member rollup — that's a
+ * separate detail call).
+ */
+export const CollectionRowSchema = z.object({
+    id: z.string(),
+    slug: z.string(),
+    name: z.string(),
+    description: z.string().nullable(),
+    isFeatured: z.boolean(),
+    /** Per-collection enable toggle for the nightly daily-summary generation. */
+    dailySummaryEnabled: z.boolean(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+/**
+ * Body for `POST /v1/collections`. `slug` derives from `name` via `toSlug()`
+ * when omitted. Slug shape is lowercased alnum + hyphens, alnum-start, 2–64
+ * chars — enforced server-side.
+ */
+export const CreateCollectionRequestSchema = z.object({
+    slug: z.string().optional(),
+    name: z.string().min(1).max(200),
+    description: z.string().max(2000).nullable().optional(),
+});
+/** Body for `PATCH /v1/collections/:slug`. All fields optional; slug rename allowed. */
+export const UpdateCollectionRequestSchema = z.object({
+    slug: z.string().optional(),
+    name: z.string().min(1).max(200).optional(),
+    description: z.string().max(2000).nullable().optional(),
+    /** Promote / demote the collection on the homepage. */
+    isFeatured: z.boolean().optional(),
+    /** Enable or disable the nightly daily-summary generation for this collection. */
+    dailySummaryEnabled: z.boolean().optional(),
+    /** Enable or disable the nightly weekly-digest generation for this collection (on by default for new collections). */
+    weeklyDigestEnabled: z.boolean().optional(),
+});
+/**
+ * One member entry accepted by the member-write endpoints.
+ *
+ * Exactly one of `orgId` / `orgSlug` / `productId` / `productSlug` must be
+ * present. When both an id and a slug are supplied for the same kind, the id
+ * wins. Mixing kinds (e.g. `orgId` + `productSlug`) is rejected by the handler.
+ *
+ * Product slug is resolved within an org — supply either `productId`
+ * (`prod_…`, globally unique) or pair `productSlug` with `orgSlug`/`orgId`.
+ * `productSlug` alone is rejected.
+ */
+export const CollectionMemberInputSchema = z.object({
+    orgId: z.string().optional(),
+    orgSlug: z.string().optional(),
+    productId: z.string().optional(),
+    productSlug: z.string().optional(),
+    /** Authoring position (default 0). For PUT, omit to use the array index. */
+    position: z.number().int().optional(),
+});
+/** Body for `POST /v1/collections/:slug/members`. */
+export const AddCollectionMemberRequestSchema = CollectionMemberInputSchema;
+/**
+ * Body for `PUT /v1/collections/:slug/members`. Replaces the full membership
+ * atomically. The field is still named `orgs` for back-compat — it accepts
+ * any `CollectionMemberInput`, org or product.
+ */
+export const ReplaceCollectionMembersRequestSchema = z.object({
+    orgs: z.array(CollectionMemberInputSchema),
+});
+/**
+ * Resolved member returned by `PUT /v1/collections/:slug/members` and `POST
+ * /v1/collections/:slug/members`. `kind` discriminates which id field is
+ * populated. `orgId` is also set on legacy callers that only used org
+ * membership — for clean dispatch, dispatch on `kind`.
+ */
+export const ResolvedCollectionMemberSchema = z.object({
+    kind: z.enum(["org", "product"]),
+    orgId: z.string().optional(),
+    productId: z.string().optional(),
+    position: z.number().int(),
+});
+/** Response from `PUT /v1/collections/:slug/members`. */
+export const ReplaceCollectionMembersResponseSchema = z.object({
+    collectionSlug: z.string(),
+    members: z.array(ResolvedCollectionMemberSchema),
+});
+/**
+ * Response from `POST /v1/collections/:slug/members`. `orgId` stays populated
+ * for org-kind members so existing CLI callers don't break; `kind` +
+ * `productId` are the canonical fields for new code.
+ */
+export const AddCollectionMemberResponseSchema = z.object({
+    collectionSlug: z.string(),
+    kind: z.enum(["org", "product"]),
+    orgId: z.string().optional(),
+    productId: z.string().optional(),
+    position: z.number().int(),
+});
+/** One daily summary row returned by `GET /v1/collections/:slug/daily-summaries`. */
+export const CollectionDailySummarySchema = z.object({
+    /** Eastern calendar day, YYYY-MM-DD. */
+    date: z.string(),
+    title: z.string(),
+    summary: z.string(),
+    takeaways: z.array(z.string()),
+    releaseCount: z.number().int().nonnegative(),
+});
+/** Response envelope for `GET /v1/collections/:slug/daily-summaries`. */
+export const CollectionDailySummariesResponseSchema = z.object({
+    summaries: z.array(CollectionDailySummarySchema),
+});
+// ── Weekly digests ────────────────────────────────────────────────
+/** List row on `GET /v1/collections/:slug/digests` — newest-first, no body. */
+export const CollectionWeeklyDigestListItemSchema = z.object({
+    id: z.string(),
+    /** ET Monday starting the covered week, YYYY-MM-DD. */
+    weekStart: z.string(),
+    title: z.string(),
+    intro: z.string(),
+    releaseCount: z.number().int().nonnegative(),
+    generatedAt: z.string(),
+});
+/** Cursor pagination shape matches the other paginated list surfaces. */
+export const CollectionWeeklyDigestsResponseSchema = z.object({
+    digests: z.array(CollectionWeeklyDigestListItemSchema),
+    pagination: CollectionFeedPaginationSchema,
+});
+/** Minimal, server-resolved release info for a digest's "Releases covered" list. */
+export const DigestCoveredReleaseSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    /** Internal `/release/*` path — fallback link only (see `url`). */
+    path: z.string(),
+    /** Upstream source URL. Primary link target when http(s); optional for older servers. */
+    url: z.string().nullable().optional(),
+    org: z.object({
+        slug: z.string(),
+        name: z.string(),
+        avatarUrl: z.string().nullable().optional(),
+        githubHandle: z.string().nullable().optional(),
+    }),
+    /** Product the release's source belongs to, when it has one. */
+    product: z.object({ slug: z.string(), name: z.string() }).nullable().optional(),
+    /**
+     * AI-scored importance 1–5. Null when unscored; optional for older
+     * servers. Cheap to project on the existing hydrate — powers the flame
+     * marker on the collapsed "Releases covered" list.
+     */
+    importance: ImportanceScoreSchema,
+    /**
+     * Per-category item counts from the AI release-content pass. Null when the
+     * row hasn't been summarized; optional for older servers. Powers the
+     * digest page's week-at-a-glance treemap.
+     */
+    composition: ReleaseCompositionSchema.nullable().optional(),
+    /**
+     * ISO publish timestamp, as stored. Null when the source gave none;
+     * optional for older servers. A date-only source is stored at exactly
+     * `T00:00:00.000Z`. Powers the digest week replay's day placement.
+     */
+    publishedAt: z.string().nullable().optional(),
+});
+/** One `###` section of a digest body, parsed server-side. */
+export const DigestSectionSchema = z.object({
+    heading: z.string(),
+    /** Slug the digest page renders as the heading's `id` — link target `#anchor`. */
+    anchor: z.string(),
+    /** First sentence of the section, plain text. */
+    lede: z.string(),
+    /** Cited release ids in first-seen order; resolve against the detail's `releases`. */
+    releaseIds: z.array(z.string()),
+    /**
+     * The section's cited releases, resolved server-side in `releaseIds` order.
+     * Ids that no longer resolve are dropped, so `releases.length` can be less
+     * than `releaseIds.length`. Optional for older servers.
+     */
+    releases: z.array(DigestCoveredReleaseSchema).optional(),
+});
+/** Full row returned by `GET /v1/collections/:slug/digests/:weekStart` and
+ *  `GET /v1/collections/:slug/digests/latest`. */
+export const CollectionWeeklyDigestDetailSchema = z.object({
+    id: z.string(),
+    weekStart: z.string(),
+    title: z.string(),
+    intro: z.string(),
+    body: z.string(),
+    releaseIds: z.array(z.string()),
+    releaseCount: z.number().int().nonnegative(),
+    generatedAt: z.string(),
+    /** Server-resolved minimal release info for every id in `releaseIds` that
+     *  still resolves — a release deleted/suppressed after generation is
+     *  dropped rather than surfaced as a dead link. */
+    releases: z.array(DigestCoveredReleaseSchema),
+    /** Parsed `###` sections. Optional for older servers. */
+    sections: z.array(DigestSectionSchema).optional(),
+});

package/dist/schemas/datasets.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export declare const DatasetDescriptionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+/** Stored under source.metadata.dataset. Null removes the override. */
+export declare const SourceDatasetSettingsSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type SourceDatasetSettings = z.infer<typeof SourceDatasetSettingsSchema>;
+export type DatasetDescription = z.infer<typeof DatasetDescriptionSchema>;
+export interface AdminDatasetSource {
+    id: string;
+    slug: string;
+    name: string;
+    orgSlug: string | null;
+    orgName: string | null;
+    defaultEnabled: boolean;
+    settings: SourceDatasetSettings | null;
+    effective: DatasetDescription | null;
+    blockedReasons: string[];
+}
+export interface AdminDatasetsResponse {
+    sources: AdminDatasetSource[];
+    pagination: {
+        page: number;
+        limit: number;
+        hasMore: boolean;
+    };
+    query: string;
+}
+//# sourceMappingURL=datasets.d.ts.map

package/dist/schemas/datasets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datasets.d.ts","sourceRoot":"","sources":["../../src/schemas/datasets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,wBAAwB;;;iBAGnC,CAAC;AAEH,uEAAuE;AACvE,eAAO,MAAM,2BAA2B;;;;kBAI7B,CAAC;AACZ,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,cAAc,EAAE,OAAO,CAAC;IACxB,QAAQ,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACvC,SAAS,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACrC,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AACD,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,UAAU,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IAC9D,KAAK,EAAE,MAAM,CAAC;CACf"}

package/dist/schemas/datasets.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export const DatasetDescriptionSchema = z.object({
+    name: z.string().trim().min(1).max(200),
+    description: z.string().trim().min(50).max(5000),
+});
+/** Stored under source.metadata.dataset. Null removes the override. */
+export const SourceDatasetSettingsSchema = DatasetDescriptionSchema.partial()
+    .extend({
+    enabled: z.boolean().optional(),
+})
+    .strict();

package/dist/schemas/errors.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { type ErrorType, type ErrorCode } from "@buildinternet/releases-core/errors";
+/**
+ * The one on-the-wire error shape. `type` is constrained (documents the
+ * contract, powers OpenAPI); `code` is an open string so a new server code an
+ * older client doesn't recognize still parses. The throwable hierarchy in
+ * `@releases/lib/releases-error` serializes to this via `toWire()`.
+ */
+export declare const errorEnvelopeSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodString;
+        type: z.ZodEnum<{
+            conflict: "conflict";
+            forbidden: "forbidden";
+            insufficient_scope: "insufficient_scope";
+            internal: "internal";
+            not_found: "not_found";
+            rate_limited: "rate_limited";
+            too_large: "too_large";
+            unauthorized: "unauthorized";
+            unavailable: "unavailable";
+            upstream: "upstream";
+            validation: "validation";
+        }>;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ErrorEnvelope = z.infer<typeof errorEnvelopeSchema>;
+export interface DecodedApiError {
+    code: string;
+    type: ErrorType;
+    message: string;
+    details?: unknown;
+}
+/**
+ * Parse an API error body into a typed, normalized shape. Forward-compatible: a
+ * malformed body or an unknown `type` degrades to `internal` and never throws.
+ */
+export declare function decodeApiError(body: unknown): DecodedApiError;
+/** True if `body` is an API error envelope; if `code` is given, also matches it. */
+export declare function isApiError(body: unknown, code?: ErrorCode): boolean;
+//# sourceMappingURL=errors.d.ts.map

package/dist/schemas/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/schemas/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAe,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,qCAAqC,CAAC;AAElG;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;iBAwB7B,CAAC;AAEJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAehE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,eAAe,CAY7D;AAED,oFAAoF;AACpF,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,CAInE"}

package/dist/schemas/errors.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { ERROR_TYPES } from "@buildinternet/releases-core/errors";
+/**
+ * The one on-the-wire error shape. `type` is constrained (documents the
+ * contract, powers OpenAPI); `code` is an open string so a new server code an
+ * older client doesn't recognize still parses. The throwable hierarchy in
+ * `@releases/lib/releases-error` serializes to this via `toWire()`.
+ */
+export const errorEnvelopeSchema = z
+    .object({
+    error: z.object({
+        code: z
+            .string()
+            .describe("Stable, specific machine code (e.g. `not_found`, `rate_limited`). Never reworded once shipped, but open-ended — branch defensively on codes you don't recognize."),
+        type: z
+            .enum(ERROR_TYPES)
+            .describe("Coarse category from a fixed set; determines the HTTP status. Safe to switch on."),
+        message: z.string().describe("Human-readable explanation. May change; do not parse."),
+        details: z
+            .unknown()
+            .optional()
+            .describe("Optional structured context carried by select codes (e.g. `database_not_initialized`)."),
+    }),
+})
+    .describe("Standardized error response — every non-2xx response uses this shape. Switch on `error.type` (fixed set → HTTP status) or match `error.code` (specific, stable). See https://releases.sh/docs/api/errors.");
+/**
+ * Lenient variant used ONLY for decode: `type` is left open so an unknown
+ * category (older client, newer server) does not reject.
+ */
+const lenientEnvelopeSchema = z.object({
+    error: z.object({
+        code: z.string(),
+        type: z.string(),
+        message: z.string(),
+        details: z.unknown().optional(),
+    }),
+});
+/**
+ * Parse an API error body into a typed, normalized shape. Forward-compatible: a
+ * malformed body or an unknown `type` degrades to `internal` and never throws.
+ */
+export function decodeApiError(body) {
+    const parsed = lenientEnvelopeSchema.safeParse(body);
+    if (!parsed.success) {
+        return { code: "internal_error", type: "internal", message: "Unknown error" };
+    }
+    const { code, type, message, details } = parsed.data.error;
+    const normalizedType = ERROR_TYPES.includes(type)
+        ? type
+        : "internal";
+    return details === undefined
+        ? { code, type: normalizedType, message }
+        : { code, type: normalizedType, message, details };
+}
+/** True if `body` is an API error envelope; if `code` is given, also matches it. */
+export function isApiError(body, code) {
+    const parsed = lenientEnvelopeSchema.safeParse(body);
+    if (!parsed.success)
+        return false;
+    return code === undefined || parsed.data.error.code === code;
+}

package/dist/schemas/feedback.d.ts

@@ -0,0 +1,134 @@
+import { z } from "zod";
+/** Feedback category — mirrors `FEEDBACK_TYPES` in `@buildinternet/releases-core/schema`. */
+export declare const FeedbackTypeSchema: z.ZodEnum<{
+    bug: "bug";
+    general: "general";
+    idea: "idea";
+    other: "other";
+}>;
+/** Triage lifecycle — mirrors `FEEDBACK_STATUSES` in `@buildinternet/releases-core/schema`. */
+export declare const FeedbackStatusSchema: z.ZodEnum<{
+    closed: "closed";
+    new: "new";
+    triaged: "triaged";
+}>;
+/**
+ * One submitted feedback row, as returned by `GET /v1/admin/feedback` and by
+ * the triage write-path (`PATCH /v1/feedback/:id` echoes the updated row).
+ * `archived` soft-removes the row from the default admin read view and is
+ * orthogonal to triage `status` — a row can be `closed` and visible, or `new`
+ * and archived. `createdAt` is epoch milliseconds.
+ */
+export declare const FeedbackItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    createdAt: z.ZodNumber;
+    message: z.ZodString;
+    contact: z.ZodNullable<z.ZodString>;
+    type: z.ZodEnum<{
+        bug: "bug";
+        general: "general";
+        idea: "idea";
+        other: "other";
+    }>;
+    status: z.ZodEnum<{
+        closed: "closed";
+        new: "new";
+        triaged: "triaged";
+    }>;
+    archived: z.ZodBoolean;
+    cliVersion: z.ZodNullable<z.ZodString>;
+    clientKind: z.ZodString;
+    anonId: z.ZodNullable<z.ZodString>;
+    os: z.ZodNullable<z.ZodString>;
+    arch: z.ZodNullable<z.ZodString>;
+    runtime: z.ZodNullable<z.ZodString>;
+    surface: z.ZodString;
+}, z.core.$strip>;
+/**
+ * `GET /v1/admin/feedback` — cursor-paginated, newest-first. Archived rows are
+ * hidden unless the request passes `?includeArchived=true`.
+ */
+export declare const FeedbackListResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        createdAt: z.ZodNumber;
+        message: z.ZodString;
+        contact: z.ZodNullable<z.ZodString>;
+        type: z.ZodEnum<{
+            bug: "bug";
+            general: "general";
+            idea: "idea";
+            other: "other";
+        }>;
+        status: z.ZodEnum<{
+            closed: "closed";
+            new: "new";
+            triaged: "triaged";
+        }>;
+        archived: z.ZodBoolean;
+        cliVersion: z.ZodNullable<z.ZodString>;
+        clientKind: z.ZodString;
+        anonId: z.ZodNullable<z.ZodString>;
+        os: z.ZodNullable<z.ZodString>;
+        arch: z.ZodNullable<z.ZodString>;
+        runtime: z.ZodNullable<z.ZodString>;
+        surface: z.ZodString;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * `PATCH /v1/feedback/:id` body — partial triage update. At least one field
+ * must be present; the response echoes the updated `FeedbackItem`.
+ */
+export declare const FeedbackUpdateBodySchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<{
+        closed: "closed";
+        new: "new";
+        triaged: "triaged";
+    }>>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** `DELETE /v1/feedback/:id` response — hard delete of a single row. */
+export declare const FeedbackDeleteResponseSchema: z.ZodObject<{
+    deleted: z.ZodLiteral<true>;
+    id: z.ZodString;
+}, z.core.$strip>;
+/** `POST /v1/feedback` field limits, shared with the handler's sanitizer. */
+export declare const FEEDBACK_MESSAGE_MIN_CHARS = 5;
+export declare const FEEDBACK_MESSAGE_MAX_CHARS = 4000;
+export declare const FEEDBACK_CONTACT_MAX_CHARS = 200;
+/**
+ * `POST /v1/feedback` body. Documentation shape: the handler sanitizes each
+ * field and coerces unknown `type` / `clientKind` values to their defaults
+ * rather than rejecting them; only a short or missing `message` is a 400.
+ */
+export declare const FeedbackSubmitBodySchema: z.ZodObject<{
+    message: z.ZodString;
+    type: z.ZodOptional<z.ZodEnum<{
+        bug: "bug";
+        general: "general";
+        idea: "idea";
+        other: "other";
+    }>>;
+    contact: z.ZodOptional<z.ZodString>;
+    clientKind: z.ZodOptional<z.ZodEnum<{
+        external: "external";
+        "internal-agent": "internal-agent";
+        "internal-ci": "internal-ci";
+        "internal-dev": "internal-dev";
+        "internal-sandbox": "internal-sandbox";
+        "mcp-stdio": "mcp-stdio";
+    }>>;
+    surface: z.ZodOptional<z.ZodString>;
+    cliVersion: z.ZodOptional<z.ZodString>;
+    anonId: z.ZodOptional<z.ZodString>;
+    os: z.ZodOptional<z.ZodString>;
+    arch: z.ZodOptional<z.ZodString>;
+    runtime: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** `POST /v1/feedback` 202 response. */
+export declare const FeedbackSubmitResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    id: z.ZodString;
+}, z.core.$strip>;
+//# sourceMappingURL=feedback.d.ts.map

package/dist/schemas/feedback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedback.d.ts","sourceRoot":"","sources":["../../src/schemas/feedback.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,6FAA6F;AAC7F,eAAO,MAAM,kBAAkB;;;;;EAAyB,CAAC;AAEzD,+FAA+F;AAC/F,eAAO,MAAM,oBAAoB;;;;EAA4B,CAAC;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;iBAe7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,wBAAwB;;;;;;;iBAGnC,CAAC;AAEH,wEAAwE;AACxE,eAAO,MAAM,4BAA4B;;;iBAGvC,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAC5C,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAC/C,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAE9C;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;iBAWnC,CAAC;AAEH,wCAAwC;AACxC,eAAO,MAAM,4BAA4B;;;iBAGvC,CAAC"}