@elevasis/ui 2.72.0 → 2.74.0

package/dist/features/content/index.d.ts

@@ -18,7 +18,9 @@ declare const OntologyScopeSchema: z.ZodDefault<z.ZodObject<{
         aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
         properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         storage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$loose>>>>;
+        rowSchema: z.ZodOptional<z.ZodString>;
+        stateCatalogId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>>;
     linkTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
         label: z.ZodOptional<z.ZodString>;
@@ -29,7 +31,7 @@ declare const OntologyScopeSchema: z.ZodDefault<z.ZodObject<{
         to: z.ZodString;
         cardinality: z.ZodOptional<z.ZodString>;
         via: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>>>;
+    }, z.core.$strict>>>>;
     actionTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
         label: z.ZodOptional<z.ZodString>;
@@ -39,7 +41,11 @@ declare const OntologyScopeSchema: z.ZodDefault<z.ZodObject<{
         actsOn: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
         input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         effects: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    }, z.core.$loose>>>>;
+        resourceId: z.ZodOptional<z.ZodString>;
+        invocations: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        lifecycle: z.ZodOptional<z.ZodString>;
+        legacyActionId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>>;
     catalogTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
         label: z.ZodOptional<z.ZodString>;
@@ -49,7 +55,10 @@ declare const OntologyScopeSchema: z.ZodDefault<z.ZodObject<{
         kind: z.ZodOptional<z.ZodString>;
         appliesTo: z.ZodOptional<z.ZodString>;
         entries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$loose>>>>;
+        legacyCatalogKey: z.ZodOptional<z.ZodString>;
+        legacyPipelineKey: z.ZodOptional<z.ZodString>;
+        legacyEntityKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>>;
     eventTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
         label: z.ZodOptional<z.ZodString>;
@@ -57,7 +66,7 @@ declare const OntologyScopeSchema: z.ZodDefault<z.ZodObject<{
         ownerSystemId: z.ZodOptional<z.ZodString>;
         aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
         payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$loose>>>>;
+    }, z.core.$strict>>>>;
     interfaceTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
         label: z.ZodOptional<z.ZodString>;
@@ -65,7 +74,7 @@ declare const OntologyScopeSchema: z.ZodDefault<z.ZodObject<{
         ownerSystemId: z.ZodOptional<z.ZodString>;
         aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
         properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$loose>>>>;
+    }, z.core.$strict>>>>;
     valueTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
         label: z.ZodOptional<z.ZodString>;
@@ -73,7 +82,7 @@ declare const OntologyScopeSchema: z.ZodDefault<z.ZodObject<{
         ownerSystemId: z.ZodOptional<z.ZodString>;
         aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
         primitive: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>>>;
+    }, z.core.$strict>>>>;
     sharedProperties: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
         label: z.ZodOptional<z.ZodString>;
@@ -83,7 +92,7 @@ declare const OntologyScopeSchema: z.ZodDefault<z.ZodObject<{
         valueType: z.ZodOptional<z.ZodString>;
         searchable: z.ZodOptional<z.ZodBoolean>;
         pii: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$loose>>>>;
+    }, z.core.$strict>>>>;
     groups: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
         label: z.ZodOptional<z.ZodString>;
@@ -91,7 +100,7 @@ declare const OntologyScopeSchema: z.ZodDefault<z.ZodObject<{
         ownerSystemId: z.ZodOptional<z.ZodString>;
         aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
         members: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
-    }, z.core.$loose>>>>;
+    }, z.core.$strict>>>>;
     endpoints: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
         label: z.ZodOptional<z.ZodString>;
@@ -99,7 +108,7 @@ declare const OntologyScopeSchema: z.ZodDefault<z.ZodObject<{
         ownerSystemId: z.ZodOptional<z.ZodString>;
         aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
         route: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>>>;
+    }, z.core.$strict>>>>;
 }, z.core.$strict>>;
 type OntologyScope = z.infer<typeof OntologyScopeSchema>;
 
@@ -191,18 +200,46 @@ interface SidebarGroupNode {
 }
 type SidebarNode = SidebarSurfaceNode | SidebarGroupNode;
 
-/** D5: who/what executes a content pipeline step. */
+/**
+ * D5: who/what executes a content pipeline step.
+ *
+ * `'human'` was added on 2026-08-21, when the workspace shell started rendering its
+ * stepper from `steps[]`. Before that a step meant "a pass that writes a
+ * `content_item_attempts` row", so the stages a person walks -- picking files,
+ * framing them, sending the post -- were declared nowhere and lived as integer
+ * constants in one tenant's page. A catalog that describes only the automated half
+ * of a pipeline cannot be the thing a workspace renders, so the vocabulary widened
+ * to cover the whole sequence rather than the shell inventing a second one.
+ *
+ * A `'human'` step writes no attempt. That is expected, not a gap: `reviewMode`
+ * still says whether a decision gates it, and the surfaces that group by
+ * `stepKey` simply find no rows against it.
+ */
 declare const ContentPipelineStepActorSchema: z.ZodEnum<{
     agent: "agent";
     workflow: "workflow";
+    human: "human";
     vendor: "vendor";
 }>;
 type ContentPipelineStepActor = z.infer<typeof ContentPipelineStepActorSchema>;
-/** D5: how a human reviews a content pipeline step's output. */
+/**
+ * D5: whether a human decision gates this step's output.
+ *
+ * Two values, deliberately. This field used to be `'live' | 'queued' | 'none'`,
+ * which encoded two independent facts in one enum -- whether a person reviews,
+ * and where they do it. `'live'` and `'queued'` differed only in the second, and
+ * the second was already stored as `workspaceRoute`. One fact written twice in
+ * two vocabularies is what let two review rules disagree on exactly one value
+ * and render a false warning on a live tenant.
+ *
+ * Where review happens is now derived rather than declared -- see
+ * `resolveContentReviewVenue`. Kept a string enum rather than a boolean so a
+ * genuine third mode later (an automated check that gates progression without a
+ * person) is an added member rather than a second schema break on this field.
+ */
 declare const ContentPipelineStepReviewModeSchema: z.ZodEnum<{
+    required: "required";
     none: "none";
-    live: "live";
-    queued: "queued";
 }>;
 type ContentPipelineStepReviewMode = z.infer<typeof ContentPipelineStepReviewModeSchema>;
 /** D17: one entry in a step's template-declared serializable payload field list. */
@@ -220,6 +257,17 @@ declare const ContentPayloadFieldDeclarationSchema: z.ZodObject<{
     required: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type ContentPayloadFieldDeclaration = z.infer<typeof ContentPayloadFieldDeclarationSchema>;
+/**
+ * Where the human decision a step gates on is actually made. Derived from
+ * `reviewMode` plus the resolved Workspace route -- see
+ * `resolveContentReviewVenue`. Never declared in a catalog.
+ *
+ * - `'none'`    -- nobody is owed a decision on this step.
+ * - `'queue'`   -- the shared review queue. The platform's own surfaces clear it.
+ * - `'workspace'` -- the tenant's own screen, named by `workspaceRoute`. The
+ *   shared surfaces display state and link out; they do not clear it.
+ */
+type ContentReviewVenue = 'none' | 'queue' | 'workspace';
 /** One step in a resolved content pipeline, as returned by `getContentBuildTemplates`. */
 interface ContentPipelineStepEntry {
     /** Matches the catalog entry id (the step's local id within its step catalog). */
@@ -232,8 +280,21 @@ interface ContentPipelineStepEntry {
     order: number;
     /** D5: who/what executes this step. */
     actor: ContentPipelineStepActor;
-    /** D5: how a human reviews this step's output. */
+    /** D5: whether a human decision gates this step's output. */
     reviewMode: ContentPipelineStepReviewMode;
+    /**
+     * Where that decision is made -- **derived, never authored.** Resolved once by
+     * `getContentBuildTemplates` via `resolveContentReviewVenue`, at the one
+     * boundary where a raw catalog becomes a resolved template and both the
+     * pipeline and the step are in hand. `ContentPipelineStepDeclarationSchema`
+     * has no such field, so no tenant can declare it and no second encoding of it
+     * can exist.
+     *
+     * Read this rather than re-deriving from `reviewMode` + `workspaceRoute` at a
+     * call site; recombining those two with `&&` at the point of use is the exact
+     * defect the content-review consolidation removed.
+     */
+    reviewVenue: ContentReviewVenue;
     /** D5: the step key this step advances to. Absent on a terminal step. */
     advancesTo?: string;
     /**
@@ -274,6 +335,15 @@ interface ContentStageCatalogEntry {
     description: string;
     order: number;
     color?: string;
+    /**
+     * The entry's own `semanticClass` -- `'open' | 'active' | 'completed'` on the
+     * status catalog, absent on catalogs that do not declare one.
+     *
+     * Carried through so a consumer can ask "is this item finished?" without
+     * hardcoding which status ids mean finished. A tenant renaming `distributed`
+     * or adding a fifth status keeps working; a hardcoded id list would not.
+     */
+    semanticClass?: string;
 }
 
 declare const OrganizationModelSchema: z.ZodObject<{
@@ -726,7 +796,9 @@ declare const OrganizationModelSchema: z.ZodObject<{
             aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
             properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             storage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$loose>>>>;
+            rowSchema: z.ZodOptional<z.ZodString>;
+            stateCatalogId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>;
         linkTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
             id: z.ZodString;
             label: z.ZodOptional<z.ZodString>;
@@ -737,7 +809,7 @@ declare const OrganizationModelSchema: z.ZodObject<{
             to: z.ZodString;
             cardinality: z.ZodOptional<z.ZodString>;
             via: z.ZodOptional<z.ZodString>;
-        }, z.core.$loose>>>>;
+        }, z.core.$strict>>>>;
         actionTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
             id: z.ZodString;
             label: z.ZodOptional<z.ZodString>;
@@ -747,7 +819,11 @@ declare const OrganizationModelSchema: z.ZodObject<{
             actsOn: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
             input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             effects: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        }, z.core.$loose>>>>;
+            resourceId: z.ZodOptional<z.ZodString>;
+            invocations: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+            lifecycle: z.ZodOptional<z.ZodString>;
+            legacyActionId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>;
         catalogTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
             id: z.ZodString;
             label: z.ZodOptional<z.ZodString>;
@@ -757,7 +833,10 @@ declare const OrganizationModelSchema: z.ZodObject<{
             kind: z.ZodOptional<z.ZodString>;
             appliesTo: z.ZodOptional<z.ZodString>;
             entries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$loose>>>>;
+            legacyCatalogKey: z.ZodOptional<z.ZodString>;
+            legacyPipelineKey: z.ZodOptional<z.ZodString>;
+            legacyEntityKey: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>;
         eventTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
             id: z.ZodString;
             label: z.ZodOptional<z.ZodString>;
@@ -765,7 +844,7 @@ declare const OrganizationModelSchema: z.ZodObject<{
             ownerSystemId: z.ZodOptional<z.ZodString>;
             aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
             payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$loose>>>>;
+        }, z.core.$strict>>>>;
         interfaceTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
             id: z.ZodString;
             label: z.ZodOptional<z.ZodString>;
@@ -773,7 +852,7 @@ declare const OrganizationModelSchema: z.ZodObject<{
             ownerSystemId: z.ZodOptional<z.ZodString>;
             aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
             properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$loose>>>>;
+        }, z.core.$strict>>>>;
         valueTypes: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
             id: z.ZodString;
             label: z.ZodOptional<z.ZodString>;
@@ -781,7 +860,7 @@ declare const OrganizationModelSchema: z.ZodObject<{
             ownerSystemId: z.ZodOptional<z.ZodString>;
             aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
             primitive: z.ZodOptional<z.ZodString>;
-        }, z.core.$loose>>>>;
+        }, z.core.$strict>>>>;
         sharedProperties: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
             id: z.ZodString;
             label: z.ZodOptional<z.ZodString>;
@@ -791,7 +870,7 @@ declare const OrganizationModelSchema: z.ZodObject<{
             valueType: z.ZodOptional<z.ZodString>;
             searchable: z.ZodOptional<z.ZodBoolean>;
             pii: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$loose>>>>;
+        }, z.core.$strict>>>>;
         groups: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
             id: z.ZodString;
             label: z.ZodOptional<z.ZodString>;
@@ -799,7 +878,7 @@ declare const OrganizationModelSchema: z.ZodObject<{
             ownerSystemId: z.ZodOptional<z.ZodString>;
             aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
             members: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
-        }, z.core.$loose>>>>;
+        }, z.core.$strict>>>>;
         endpoints: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
             id: z.ZodString;
             label: z.ZodOptional<z.ZodString>;
@@ -807,7 +886,7 @@ declare const OrganizationModelSchema: z.ZodObject<{
             ownerSystemId: z.ZodOptional<z.ZodString>;
             aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
             route: z.ZodOptional<z.ZodString>;
-        }, z.core.$loose>>>>;
+        }, z.core.$strict>>>>;
     }, z.core.$strict>>>;
     resources: z.ZodDefault<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
         id: z.ZodString;
@@ -1263,6 +1342,13 @@ declare const OrganizationModelSchema: z.ZodObject<{
 type OrganizationModel = z.infer<typeof OrganizationModelSchema>;
 type OrganizationModelResourceKind = z.infer<typeof ResourceKindSchema>;
 
+/** Response-side crop: unknown keys are stripped, not rejected, like every other response schema here. */
+declare const ContentAssetCropSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
 declare const ContentItemResponseSchema: z.ZodObject<{
     id: z.ZodString;
     organizationId: z.ZodString;
@@ -1274,6 +1360,29 @@ declare const ContentItemResponseSchema: z.ZodObject<{
     pipelineId: z.ZodNullable<z.ZodString>;
     clientId: z.ZodNullable<z.ZodString>;
     sourceAssetId: z.ZodNullable<z.ZodString>;
+    sourceAssets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        organizationId: z.ZodString;
+        contentItemId: z.ZodString;
+        sourceAssetId: z.ZodString;
+        position: z.ZodNumber;
+        crop: z.ZodNullable<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>>;
+        altText: z.ZodNullable<z.ZodString>;
+        derivativePath: z.ZodNullable<z.ZodString>;
+        derivativeCrop: z.ZodNullable<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>>;
+        derivativeRenderedAt: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>>;
     processingState: z.ZodRecord<z.ZodString, z.ZodObject<{
         status: z.ZodEnum<{
             error: "error";
@@ -1296,7 +1405,76 @@ declare const ContentItemResponseSchema: z.ZodObject<{
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
 }, z.core.$strip>;
+declare const ContentSourceAssetResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    organizationId: z.ZodString;
+    kind: z.ZodString;
+    title: z.ZodString;
+    externalUrl: z.ZodNullable<z.ZodString>;
+    storagePath: z.ZodNullable<z.ZodString>;
+    durationSeconds: z.ZodNullable<z.ZodNumber>;
+    metadata: z.ZodUnknown;
+    payload: z.ZodUnknown;
+    processingState: z.ZodRecord<z.ZodString, z.ZodObject<{
+        status: z.ZodEnum<{
+            error: "error";
+            success: "success";
+            running: "running";
+            no_result: "no_result";
+            skipped: "skipped";
+        }>;
+        attemptId: z.ZodString;
+        executionId: z.ZodNullable<z.ZodString>;
+        attemptedAt: z.ZodString;
+        data: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+declare const ContentDistributionResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    organizationId: z.ZodString;
+    contentItemId: z.ZodString;
+    platform: z.ZodString;
+    format: z.ZodString;
+    status: z.ZodString;
+    adaptedBody: z.ZodNullable<z.ZodString>;
+    platformContent: z.ZodNullable<z.ZodUnknown>;
+    checklist: z.ZodNullable<z.ZodUnknown>;
+    mediaUrls: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"storage">;
+        bucket: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"url">;
+        url: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    processingState: z.ZodRecord<z.ZodString, z.ZodObject<{
+        status: z.ZodEnum<{
+            error: "error";
+            success: "success";
+            running: "running";
+            no_result: "no_result";
+            skipped: "skipped";
+        }>;
+        attemptId: z.ZodString;
+        executionId: z.ZodNullable<z.ZodString>;
+        attemptedAt: z.ZodString;
+        data: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>;
+    publishMethod: z.ZodNullable<z.ZodString>;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    platformPostId: z.ZodNullable<z.ZodString>;
+    platformUrl: z.ZodNullable<z.ZodString>;
+    metrics: z.ZodUnknown;
+    metricsUpdatedAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+type ContentAssetCrop = z.infer<typeof ContentAssetCropSchema>;
 type ContentItemResponse = z.infer<typeof ContentItemResponseSchema>;
+type ContentSourceAssetResponse = z.infer<typeof ContentSourceAssetResponseSchema>;
+type ContentDistributionResponse = z.infer<typeof ContentDistributionResponseSchema>;
 
 /**
  * `deriveContentBoard` -- a pure function of `(items, pipeline, now)`. No React, no
@@ -1344,15 +1522,23 @@ interface ContentBoardCard {
     awaitingReview: boolean;
 }
 interface ContentBoardGate {
-    /** The review mode of the step this gate follows. Never 'none' -- a 'none' step has no gate. */
-    reviewMode: Exclude<ContentPipelineStepReviewMode, 'none'>;
+    /**
+     * Where this gate's review happens. Never `'none'` -- a step nobody reviews
+     * has no gate at all.
+     *
+     * This replaced a `reviewMode` field when the enum collapsed to
+     * `'none' | 'required'`, which would have left every gate reporting the same
+     * constant. Venue is the fact a consumer actually renders: the CLI's board
+     * label and the UI's column header both need to say *where*, not *whether*.
+     */
+    venue: Exclude<ContentReviewVenue, 'none'>;
     /** How many cards in the preceding column are awaiting review. */
     waitingCount: number;
 }
 interface ContentBoardColumn {
     step: ContentPipelineStepEntry;
     cards: ContentBoardCard[];
-    /** Present when this step's reviewMode is 'live' or 'queued'. Absent on a 'none' step. */
+    /** Present when this step's `reviewVenue` is not `'none'`. A step nobody reviews has no gate. */
     gate?: ContentBoardGate;
 }
 interface ContentBoard {
@@ -1388,6 +1574,39 @@ declare function deriveContentBoard(items: ContentItemResponse[], pipeline: Cont
  */
 declare function getContentItemIdentity(item: Pick<ContentItemResponse, 'title' | 'body' | 'payload'>, payloadFields?: ContentPayloadFieldDeclaration[], maxLength?: number): string;
 
+/**
+ * Storage-neutral file descriptor.
+ *
+ * Dropbox and Google Drive (the foreseeable second provider) both ship
+ * their own file/metadata shapes. Consumers on both sides of the wire —
+ * a UI file browser and the API route that talks to the provider — need
+ * to agree on one normalized shape, which is why it lives here instead
+ * of being duplicated in each consumer.
+ *
+ * Adapters (`createDropboxAdapter`, a future Drive adapter) stay concrete
+ * and keep their own provider-shaped responses. Normalization into this
+ * type happens at the route/hook boundary — a few lines per provider,
+ * not behind a shared `CloudStorageAdapter` interface.
+ */
+interface CloudStorageFile {
+    id: string;
+    name: string;
+    kind: 'file' | 'folder';
+    path?: string;
+    mimeType?: string;
+    sizeBytes?: number;
+    width?: number;
+    height?: number;
+    /** ISO 8601 timestamp the asset was captured (e.g. photo EXIF date), when the provider exposes one. */
+    capturedAt?: string;
+    /**
+     * Optional on purpose. Dropbox does not produce a thumbnail for HEIC or
+     * for anything over 20 MB — "no thumbnail" is a normal state a consumer
+     * renders a fallback for, not an error.
+     */
+    thumbnailUrl?: string;
+}
+
 type SystemSidebarComponent = ComponentType;
 type SystemIconComponent = ComponentType<{
     size?: number;
@@ -1807,6 +2026,306 @@ interface ContentReviewCardProps {
  */
 declare function ContentReviewCard({ title, body, onBodyChange, originalBody, onReset, payload, payloadFields, fidelity, checkFirst, hookOptions, closeOptions, onMoreHooks, onMoreCloses, alternatesRunning, alternatesElapsed, processingSteps, actions, onAction, actionsPending, readOnly }: ContentReviewCardProps): react_jsx_runtime.JSX.Element;
 
+interface SelectedAssetStripProps {
+    /**
+     * The selection, in carousel order. Index 0 is the cover slide -- there is no
+     * separate `isCover` flag to keep in sync, because the planned
+     * `content_item_source_assets` link table persists this same array as a `position`
+     * column where `position = 0` IS the cover by definition.
+     */
+    assets: CloudStorageFile[];
+    /** Fires with the full reordered array whenever the user drags a slide to a new position. */
+    onReorder: (assets: CloudStorageFile[]) => void;
+}
+/**
+ * Ordered strip of the assets selected for a multi-asset content item (an Instagram
+ * carousel post's slides). Presentational -- data in via `assets`, order changes out
+ * via `onReorder`, no fetching. Drag-reorder uses native HTML5 drag events, matching
+ * the pattern already established for `KanbanBoard` / `DealKanbanCard` rather than
+ * introducing a new drag-and-drop dependency for one strip.
+ */
+declare function SelectedAssetStrip({ assets, onReorder }: SelectedAssetStripProps): react_jsx_runtime.JSX.Element;
+
+interface SourceAssetsPanelProps {
+    /** The content item whose membership this panel reads and writes. */
+    itemId: string;
+}
+/**
+ * Operator surface for a content item's ordered source-asset membership -- the
+ * carousel. Reads `content_item_source_assets` and drives all four membership
+ * writes: link, unlink, reorder, and per-slide alt text.
+ *
+ * This exists because the membership write path had no surface at all: it is not on
+ * the CLI, the external API-key routes were deliberately not extended (Open Decision
+ * 10), and the seed workflow still creates items through the legacy singular
+ * `sourceAssetId`. Everything below the hooks was therefore covered by unit tests
+ * only and had never been executed end to end. A basic table is enough to fix that,
+ * and a tenant that wants a picture-first carousel editor builds its own on the same
+ * hooks.
+ *
+ * Two ordering surfaces on purpose. `SelectedAssetStrip` is the picture-first one and
+ * is what tenants get from the `./features/content` subpath, so it is mounted here
+ * against real persisted membership rather than left to render only under test. The
+ * table underneath keeps move up / move down because drag is unusable by keyboard and
+ * unavailable to a screen reader. Both send the identical complete ordered list.
+ *
+ * The strip takes `CloudStorageFile`, which a membership is not -- the mapping below is
+ * the whole adapter. Content source assets carry no thumbnail yet (that arrives with
+ * Dropbox intake), so every tile renders the strip's no-thumbnail fallback today.
+ *
+ * The crop column opens `AssetCropEditor` against the original's bytes, resolved
+ * one file at a time while the modal is open. Only an asset carrying a
+ * cloud-storage reference can be cropped -- there is nothing to crop against
+ * otherwise -- so a seeded or text-backed asset shows the button disabled.
+ *
+ * Positions are shown as stored, not as row indexes. Non-contiguous positions are
+ * legal -- only uniqueness within an item is enforced -- so an item assembled by
+ * individual links can legitimately have no `position` 0, and the cover is the lowest
+ * position present rather than a literal 0.
+ */
+declare function SourceAssetsPanel({ itemId }: SourceAssetsPanelProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * A carousel aspect option. `ratio` is width / height in PIXELS -- `null` means
+ * "whatever the source already is", which is the only option that never crops.
+ */
+interface CropAspectOption {
+    value: string;
+    label: string;
+    ratio: number | null;
+}
+/**
+ * The three shapes a photo post actually takes, plus the uncropped original.
+ * Portrait 4:5 leads because it is the tallest a feed will show without
+ * cropping the image itself, so it is the default for a carousel.
+ */
+declare const CROP_ASPECT_OPTIONS: CropAspectOption[];
+interface AssetCropEditorProps {
+    /**
+     * The FULL-RESOLUTION image. A thumbnail will not do: the crop is stored as
+     * fractions of the source, and a downsampled copy shows the operator a
+     * different frame from the one that gets published.
+     */
+    imageUrl: string | null;
+    /** The stored crop, or `null` for "uncropped". */
+    value: ContentAssetCrop | null;
+    /** Fires on every committed change. `null` clears the crop back to the full frame. */
+    onChange: (crop: ContentAssetCrop | null) => void;
+    /** Which aspect the control starts on. Defaults to the source's own shape. */
+    defaultAspect?: string;
+    /** Locks the aspect selector -- a carousel wants one ratio across every slide. */
+    aspect?: string;
+    disabled?: boolean;
+    /** Shown above the frame, e.g. `Slide 1`. */
+    label?: string;
+}
+/**
+ * Picks the crop box out of a normalized frame, over the image itself.
+ *
+ * The emitted value is exactly what `ContentAssetCropInputSchema` validates:
+ * `{ x, y, width, height }` as fractions of the source, `0,0` at the top-left.
+ * Fractions rather than pixels because the same crop has to survive a resized
+ * derivative, which is also why this needs the original rather than a thumbnail.
+ *
+ * **Aspect is expressed in pixels and stored in fractions**, and the two are not
+ * the same number on a non-square image -- a 1:1 crop of a 4000x3000 photo is
+ * `width: 0.75, height: 1`. `fitBox` is the whole of that conversion.
+ *
+ * Two controls, not a free-form rubber band: an aspect and a size, with the frame
+ * dragged into place. A free rectangle lets an operator produce a shape no feed
+ * will render, and the failure only shows up after posting.
+ */
+declare function AssetCropEditor({ imageUrl, value, onChange, defaultAspect, aspect, disabled, label }: AssetCropEditorProps): react_jsx_runtime.JSX.Element;
+
+/** One slide, in carousel order. */
+interface PostPreviewSlide {
+    /** Stable per-slide key -- the source asset id, or the storage file id before one exists. */
+    id: string;
+    /** The full-resolution image. `null` renders the empty frame rather than a broken one. */
+    imageUrl: string | null;
+    /** The stored crop, or `null` for the uncropped original. */
+    crop?: ContentAssetCrop | null;
+    altText?: string | null;
+}
+interface PostPreviewProps {
+    slides: PostPreviewSlide[];
+    /** The caption as it would post. `null` renders the "no caption yet" line. */
+    caption?: string | null;
+    hashtags?: string[];
+    /** Frame shape, width / height in pixels. Defaults to the 4:5 portrait a carousel uses. */
+    aspectRatio?: number;
+    /** Shown above the frame, e.g. the item title. */
+    title?: string;
+}
+/**
+ * The carousel as it will actually post: slides in position order, each one
+ * showing only the part its crop keeps, with the caption underneath.
+ *
+ * **The crop is applied here, not baked into any file.** Nothing in this
+ * pipeline writes a cropped derivative -- `content_item_source_assets.crop` is
+ * a normalized box, and every surface that renders a slide applies it. This
+ * component is the reference implementation of that, and the reason it is
+ * shared rather than page-local.
+ *
+ * The technique is an oversized absolutely-positioned image inside an
+ * overflow-hidden frame: an image scaled to `1 / crop.width` of the frame and
+ * offset by `-crop.x / crop.width` puts exactly the kept region in view, in
+ * pure CSS and with no canvas step. `object-fit: cover` stays on so a slide
+ * whose crop aspect does not match the frame is trimmed rather than stretched.
+ */
+declare function PostPreview({ slides, caption, hashtags, aspectRatio, title }: PostPreviewProps): react_jsx_runtime.JSX.Element;
+/**
+ * Positions the image so the frame shows only the crop's region.
+ *
+ * Exported for the unit test: the arithmetic is the one part of this component
+ * that can be silently wrong, and asserting it through a rendered style string
+ * is what catches an inverted sign.
+ */
+declare function cropStyle(crop: ContentAssetCrop | null): React.CSSProperties;
+
+/**
+ * Rendering a crop to an actual file.
+ *
+ * `cropStyle` in `PostPreview` renders the same crop with CSS, which is right for
+ * a preview and useless for posting: the cropped image never exists as bytes, so
+ * there is nothing to download and nothing to hand a platform. This module is the
+ * other half -- the same four normalized numbers, resolved into a JPEG.
+ *
+ * It runs in the browser on purpose. The pixels are already decoded there (the
+ * crop editor and the preview share one download of the original), the source is
+ * a short-lived provider link the server would have to re-fetch, and no image
+ * library exists anywhere in this monorepo -- putting this on the server would
+ * mean adding the first native image binary to a service whose build is a no-op.
+ * A spike on 2026-08-19 confirmed Dropbox's temporary-link hosts send permissive
+ * CORS, so the canvas is not tainted and `toBlob` succeeds.
+ */
+/** The private, org-scoped, RLS-gated bucket derivatives live in. */
+declare const CONTENT_DERIVATIVES_BUCKET = "content-derivatives";
+/**
+ * Widest edge a derivative is encoded at.
+ *
+ * 1080 is what Instagram renders a feed image at; anything wider is downsampled on
+ * upload, so the extra bytes buy nothing. A crop smaller than this is never
+ * upscaled to reach it -- see `renderCropToJpeg`.
+ */
+declare const DERIVATIVE_MAX_WIDTH = 1080;
+/** JPEG quality. 0.9 measured at 84-104 KB for a 1080x1350 slide. */
+declare const DERIVATIVE_JPEG_QUALITY = 0.9;
+/**
+ * Object key for one slide's derivative, WITHOUT the `{organizationId}/` prefix --
+ * `StorageService.buildPath` prepends that server-side, and the `storage.objects`
+ * policies read the org back out of it.
+ *
+ * Keyed by item and source asset rather than by membership id so a re-render
+ * overwrites the previous derivative instead of accumulating one file per edit.
+ * The pair is unique within an item by database constraint, which is what makes
+ * that safe.
+ */
+declare function derivativeObjectKey(contentItemId: string, sourceAssetId: string): string;
+/**
+ * Whether the stored derivative no longer matches the crop it is supposed to show.
+ *
+ * Derived, never stored: a `derivativeIsStale` column would be a second encoding of
+ * what these two values already say, and the two could disagree. A membership with
+ * no crop has nothing to render, and one with no derivative is missing rather than
+ * stale -- both return false, because neither is a file that needs replacing.
+ */
+declare function isDerivativeStale(crop: ContentAssetCrop | null, derivativeCrop: ContentAssetCrop | null, derivativePath: string | null): boolean;
+interface RenderCropOptions {
+    /** Widest edge to encode at. Defaults to `DERIVATIVE_MAX_WIDTH`. */
+    maxWidth?: number;
+    /** JPEG quality, 0-1. Defaults to `DERIVATIVE_JPEG_QUALITY`. */
+    quality?: number;
+}
+/**
+ * Render a crop box against its source image and return the cropped JPEG.
+ *
+ * `crop` is normalized fractions of the source, exactly as stored -- so this
+ * survives the source being a different pixel size than it was when the crop was
+ * drawn. A `null` crop renders the whole frame, which still does real work: it
+ * normalizes the format and caps the size.
+ *
+ * The output is never upscaled past the cropped region's own pixel count. A tight
+ * crop of a small original produces a smaller file rather than a blurry 1080px
+ * one, and a platform that wants 1080 will upscale it either way.
+ *
+ * Throws rather than returning null on a tainted canvas or an unloadable URL:
+ * silently storing no derivative is indistinguishable from never having tried.
+ */
+declare function renderCropToJpeg(imageUrl: string, crop: ContentAssetCrop | null, options?: RenderCropOptions): Promise<Blob>;
+
+/** The `content:catalog/photo-carousel-steps` entry this panel drives. */
+declare const CAPTION_STEP_KEY = "caption-generation";
+/** The OM Resource bound to `content:action/caption-generation`. */
+declare const CAPTION_WORKFLOW_ID = "cnt-caption-generation-workflow";
+interface CaptionPanelProps {
+    itemId: string;
+    /** The item's current `body`, so the panel can mark which attempt is the live caption. */
+    body?: string | null;
+    /**
+     * Called on every keystroke with the unsaved caption text.
+     *
+     * This exists so a preview rendered beside the editor updates as the operator
+     * types rather than one autosave later. Consumers that only care about the
+     * persisted value can ignore it and read `body` as before.
+     */
+    onDraftChange?: (draft: string) => void;
+}
+/**
+ * Generate a caption for a carousel, regenerate it, and pick which one becomes
+ * the item's body.
+ *
+ * **Regeneration does not overwrite.** Every run of
+ * `cnt-caption-generation-workflow` writes its own `content_item_attempts` row,
+ * so a second caption competes with the first rather than replacing it, and the
+ * one the operator liked stays reachable after they try something else. Nothing
+ * here is promoted automatically: `content_items.body` changes only when someone
+ * presses Use, which is exactly what the step's `reviewMode: 'required'` means.
+ *
+ * The workflow runs asynchronously and the panel polls its execution, because
+ * a vision-informed caption over several slides regularly outruns the API's
+ * 60-second synchronous request timeout.
+ */
+declare function CaptionPanel({ itemId, body, onDraftChange }: CaptionPanelProps): react_jsx_runtime.JSX.Element;
+
+/** The OM Resource bound to `content:action/image-analysis`. */
+declare const IMAGE_ANALYSIS_WORKFLOW_ID = "cnt-image-analysis-workflow";
+interface SlideAnalysisPanelProps {
+    itemId: string;
+}
+/**
+ * What `cnt-image-analysis-workflow` writes to `content_source_assets.metadata.analysis`.
+ * Every field is read defensively: the column is free-form jsonb, so an older row, a
+ * hand-edited one, or one written by a future version of the workflow may carry
+ * anything at all.
+ */
+interface StoredSlideAnalysis {
+    description?: string;
+    subjects?: string[];
+    setting?: string;
+    mood?: string;
+    textInImage?: string;
+    altText?: string;
+    model?: string;
+    generatedAt?: string;
+}
+/** Reads the analysis off an asset, or `null` when it has never been analysed. */
+declare function readStoredAnalysis(asset: ContentSourceAssetResponse | undefined): StoredSlideAnalysis | null;
+/**
+ * Runs image analysis over a carousel's slides and shows what came back.
+ *
+ * **The analysis lives on the ASSET, not on the membership** (Open Decision 14).
+ * It describes the photograph, so it is written once per photo and every item
+ * that uses that photo reads the same description -- and a re-crop does not
+ * invalidate it. The per-slide fields beside it (`crop`, `altText`) stay on the
+ * membership, where a slide's role in one particular carousel belongs.
+ *
+ * Re-running is a plain overwrite here, unlike captions: there is no competing
+ * "which description is better" judgement to preserve, and an analysis is an
+ * input to the caption rather than something anyone publishes.
+ */
+declare function SlideAnalysisPanel({ itemId }: SlideAnalysisPanelProps): react_jsx_runtime.JSX.Element;
+
 /** A single tenant-facing noun with singular and plural forms, e.g. `{ singular: 'Post', plural: 'Posts' }`. */
 interface ContentNoun {
     singular: string;
@@ -1975,7 +2494,7 @@ interface ContentSidebarProps {
 declare const ContentSidebar: ({ workspaceItems, createItems, children }?: ContentSidebarProps) => react_jsx_runtime.JSX.Element;
 
 /**
- * Static two-entry default, built from {@link DEFAULT_CONTENT_VOCABULARY}. Exists for
+ * Static three-entry default, built from {@link DEFAULT_CONTENT_VOCABULARY}. Exists for
  * consumers that spread it at module load time (see `extend-content.md`), where a
  * tenant's declared vocabulary isn't available. `ContentSidebarMiddle` itself renders
  * the live, vocabulary-aware version instead of this constant.
@@ -2000,7 +2519,7 @@ interface ContentSidebarMiddleProps {
      * that section now holds review too.
      */
     createItems?: NavItem[];
-    /** Override the pipeline nav items. Defaults to the two-entry nav built from the tenant's declared vocabulary. */
+    /** Override the pipeline nav items. Defaults to the three-entry nav built from the tenant's declared vocabulary. */
     items?: NavItem[];
 }
 /**
@@ -2038,8 +2557,8 @@ interface MyReviewQueuePanelProps {
  * cross-pipeline "what needs review" view rather than a panel beside a table browser.
  *
  * The `/content/items` route accepts no "pending review" filter (only `reviewedBy`, not
- * a reviewed/unreviewed flag), so this fetches a page of items and filters to
- * `reviewedAt === null` client-side. A future backend addition could push this
+ * a reviewed/unreviewed flag), so this fetches a page of items and filters to the ones
+ * `isAwaitingReview` client-side. A future backend addition could push this
  * server-side; documenting the gap here rather than silently over-claiming precision.
  *
  * Rows are ordered oldest-first by `updatedAt` -- finding 6 is that nothing on the
@@ -2048,5 +2567,170 @@ interface MyReviewQueuePanelProps {
  */
 declare function MyReviewQueuePanel({ onItemClick, onSeeAll, showSectionLabel }: MyReviewQueuePanelProps): react_jsx_runtime.JSX.Element;
 
-export { AlternatesPanel, CONTENT_ITEMS, ContentDistributionDetailPage, ContentDistributionsPage, ContentItemReviewPage, ContentItemsPage, ContentOverviewPage, ContentPipelineBoardPage, ContentPipelineBoardPage as ContentPipelineWorkspacePage, ContentPipelinesPage, ContentReviewCard, ContentSidebar, ContentSidebarMiddle, DEFAULT_CONTENT_VOCABULARY, MyReviewQueuePanel, PayloadBody, ProcessingStateStrip, ReviewActionBar, contentManifest, deriveContentBoard, firstLine, formatElapsed, getContentItemIdentity, lastLine, resolveContentStepResource, resolveContentVocabulary, swapFirstLine, swapLastLine, useContentConfig };
-export type { AlternatesPanelProps, ContentAlternateOption, ContentBoard, ContentBoardCard, ContentBoardColumn, ContentBoardGate, ContentConfig, ContentDistributionDetailPageSlots, ContentDistributionsPageSlots, ContentFidelityCheck, ContentItemReviewPageSlots, ContentItemsPageSlots, ContentNoun, ContentOverviewPageSlots, ContentPayloadField, ContentPipelineBoardPageSlots, ContentPipelineBoardPageSlots as ContentPipelineWorkspacePageSlots, ContentPipelinesPageSlots, ContentProcessingStatus, ContentProcessingStep, ContentReviewAction, ContentReviewCardProps, ContentSidebarMiddleProps, ContentSidebarProps, ContentStepResourceBinding, ContentVocabulary, MyReviewQueuePanelProps, PayloadBodyProps, ProcessingStateStripProps, ReviewActionBarProps, ReviewMode };
+/**
+ * What every step panel is handed, and the only thing the workspace shell owns.
+ *
+ * The shell fixes four things and nothing else: it remembers the work in progress,
+ * it moves between steps, it draws the stepper from the tenant's own step list, and
+ * it renders the panel that tenant's map names for the active step. Step count, step
+ * order, labels, actors, review modes, statuses, platforms and every screen a step
+ * puts up come from the model and from the composing app.
+ *
+ * `TDraft` is whatever the composing app's panels share and the shell has no opinion
+ * about -- a cloud-storage selection, per-slide crops, a chosen platform. It is
+ * carried, never read.
+ */
+interface ContentWorkspaceState<TDraft> {
+    /** The pipeline being walked, resolved from the organization model. */
+    pipeline: ContentPipelineTemplate;
+    /** Its steps, in declared order. Never assume a length or a particular member. */
+    steps: ContentPipelineStepEntry[];
+    /** The step on screen. */
+    step: ContentPipelineStepEntry;
+    /** Its index within {@link steps}. */
+    stepIndex: number;
+    /**
+     * The item, once something has written one. `null` before that.
+     *
+     * Kept live rather than held as the create response: a caption promoted by a panel
+     * changes `body`, and a preview reading the create snapshot would show the old one.
+     */
+    item: ContentItemResponse | null;
+    /** Adopt a written item -- after creating one, or on resuming an existing one. */
+    setItem: (item: ContentItemResponse | null) => void;
+    /**
+     * The item's body as it stands: the unsaved draft when a panel has reported one,
+     * the saved body otherwise.
+     *
+     * This is shell state rather than tenant draft state because every pipeline that
+     * writes a body has an in-progress one, and more than one step reads it -- the step
+     * that writes it, the preview beside it, and the step that sends it out. Leaving it
+     * to each app is how the two disagree.
+     */
+    body: string;
+    /** The unsaved body, or `null` when no panel has reported one. */
+    bodyDraft: string | null;
+    setBodyDraft: (draft: string | null) => void;
+    /**
+     * The distribution row for this item, or `null`. First row only -- a second
+     * platform is a second distribution and nothing here creates one yet.
+     */
+    distribution: ContentDistributionResponse | null;
+    /** Re-read the distributions after a panel has written one. */
+    refetchDistributions: () => void;
+    /** Whatever the composing app's own panels share. */
+    draft: TDraft;
+    /** Merge a patch, or replace via an updater. */
+    setDraft: (update: Partial<TDraft> | ((current: TDraft) => TDraft)) => void;
+    /** Move to a step by key. Ignored when the key names no step in this pipeline. */
+    goToStep: (stepKey: string) => void;
+    goToNextStep: () => void;
+    goToPreviousStep: () => void;
+    /** Whether a step can be opened right now, per the composing app's own rule. */
+    canOpenStep: (step: ContentPipelineStepEntry) => boolean;
+    /**
+     * Install a guard the shell awaits before leaving the active step, or clear it
+     * with `null`.
+     *
+     * This exists because some steps have work that only makes sense to finish on the
+     * way out -- rendering a crop, flushing an edit -- and the panel is the only thing
+     * that knows what that work is. Install it from an effect and clear it on unmount.
+     */
+    registerLeaveGuard: (guard: ((to: ContentPipelineStepEntry) => Promise<void> | void) | null) => void;
+    /** Drop everything and return to the start. */
+    restart: () => void;
+}
+/** A component registered to render one step. */
+type ContentStepPanel<TDraft> = ComponentType<ContentWorkspaceState<TDraft>>;
+/**
+ * Which panel renders which step, keyed by step key.
+ *
+ * An explicit map rather than a convention on the step key: a tenant that renames a
+ * step would otherwise silently lose its panel with nothing on screen to say so,
+ * whereas a missing entry here is reported. It also takes any component, so a tenant
+ * can use published panels for some steps and its own for the rest.
+ */
+type ContentStepPanelMap<TDraft> = Record<string, ContentStepPanel<TDraft>>;
+/** What the opening screen can do, when the composing app renders one. */
+interface ContentWorkspaceStartControls {
+    /** Begin a new item at the first step. */
+    onStartNew: () => void;
+    /** Pick up an existing item. The shell adopts it and opens `resumeAtStepKey`. */
+    onResume: (item: ContentItemResponse, resumeAtStepKey?: string) => void;
+}
+interface ContentWorkspaceShellProps<TDraft> {
+    /**
+     * Which pipeline to walk. Defaults to the content System's own
+     * `config.defaultPipelineId` when omitted.
+     */
+    pipelineId?: string;
+    /** See {@link ContentStepPanelMap}. */
+    panels: ContentStepPanelMap<TDraft>;
+    /** The starting value of the app's own shared draft. Also what `restart` returns to. */
+    initialDraft: TDraft;
+    title: string;
+    caption?: string;
+    /** Rendered at the right of the page title -- a credential badge, a mode switch. */
+    headerRight?: ReactNode;
+    /**
+     * The opening screen, before any step is shown: a resume picker, a template
+     * chooser, or nothing. Omit it and the shell opens on the first step.
+     */
+    renderStart?: (controls: ContentWorkspaceStartControls) => ReactNode;
+    /**
+     * Rendered on every step whatever panel is active, between the stepper and the
+     * panel. For the banner naming the work in progress, and for cross-step effects
+     * that must outlive the panel that started them.
+     */
+    renderPersistent?: (state: ContentWorkspaceState<TDraft>) => ReactNode;
+    /**
+     * The column beside the active panel -- typically the thing being built. Return
+     * `null` for a step that wants the full width, and the shell drops the column
+     * rather than rendering an empty one.
+     */
+    renderAside?: (state: ContentWorkspaceState<TDraft>) => ReactNode;
+    /**
+     * Whether a step is openable. Defaults to "any step at or before the furthest one
+     * reached", which is what makes going back free and going forward deliberate.
+     */
+    canOpenStep?: (step: ContentPipelineStepEntry, state: ContentWorkspaceState<TDraft>) => boolean;
+    /** Test id on the page root, so a composing app's tests can find its own workspace. */
+    testId?: string;
+}
+
+/**
+ * The frame a tenant's content pipeline is walked in.
+ *
+ * **It draws the stepper from the model, not from itself.** One `Stepper.Step` per
+ * entry in `ContentPipelineTemplate.steps`, using that entry's own label and order,
+ * its description below the row once the step is active, and the panel the composing
+ * app registered for its key. A pipeline with
+ * three steps renders three; one with seven renders seven; one that puts the caption
+ * second renders it second. Nothing here knows what a crop or a carousel is.
+ *
+ * **It owns only what every step shares** -- the item, its unsaved body, the
+ * distribution row, and where in the sequence you are. Everything else is the
+ * composing app's, carried through `draft` untouched. The panels are stateless and
+ * take this object; the app decides what they are.
+ *
+ * The reason the frame owns that much rather than less: those are exactly the values
+ * more than one step reads, and the two live defects in the page this replaced were
+ * both cross-step state bugs. Pushing them into each app reproduces those bugs once
+ * per tenant.
+ */
+declare function ContentWorkspaceShell<TDraft>({ pipelineId, panels, initialDraft, title, caption, headerRight, renderStart, renderPersistent, renderAside, canOpenStep, testId }: ContentWorkspaceShellProps<TDraft>): react_jsx_runtime.JSX.Element;
+
+/**
+ * The analysis step, ready to register.
+ *
+ * `SlideAnalysisPanel` was already universal -- it takes an item id and nothing else
+ * -- so what was missing was only the shape the shell calls it with. That is all this
+ * is: the panel, plus the two moves either side of it.
+ *
+ * Registers under whatever key the tenant's own step catalog uses; nothing here reads
+ * a step key.
+ */
+declare function ContentAnalysisStepPanel<TDraft>(state: ContentWorkspaceState<TDraft>): react_jsx_runtime.JSX.Element;
+
+export { AlternatesPanel, AssetCropEditor, CAPTION_STEP_KEY, CAPTION_WORKFLOW_ID, CONTENT_DERIVATIVES_BUCKET, CONTENT_ITEMS, CROP_ASPECT_OPTIONS, CaptionPanel, ContentAnalysisStepPanel, ContentDistributionDetailPage, ContentDistributionsPage, ContentItemReviewPage, ContentItemsPage, ContentOverviewPage, ContentPipelineBoardPage, ContentPipelineBoardPage as ContentPipelineWorkspacePage, ContentPipelinesPage, ContentReviewCard, ContentSidebar, ContentSidebarMiddle, ContentWorkspaceShell, DEFAULT_CONTENT_VOCABULARY, DERIVATIVE_JPEG_QUALITY, DERIVATIVE_MAX_WIDTH, IMAGE_ANALYSIS_WORKFLOW_ID, MyReviewQueuePanel, PayloadBody, PostPreview, ProcessingStateStrip, ReviewActionBar, SelectedAssetStrip, SlideAnalysisPanel, SourceAssetsPanel, contentManifest, cropStyle, derivativeObjectKey, deriveContentBoard, firstLine, formatElapsed, getContentItemIdentity, isDerivativeStale, lastLine, readStoredAnalysis, renderCropToJpeg, resolveContentStepResource, resolveContentVocabulary, swapFirstLine, swapLastLine, useContentConfig };
+export type { AlternatesPanelProps, AssetCropEditorProps, CaptionPanelProps, ContentAlternateOption, ContentBoard, ContentBoardCard, ContentBoardColumn, ContentBoardGate, ContentConfig, ContentDistributionDetailPageSlots, ContentDistributionsPageSlots, ContentFidelityCheck, ContentItemReviewPageSlots, ContentItemsPageSlots, ContentNoun, ContentOverviewPageSlots, ContentPayloadField, ContentPipelineBoardPageSlots, ContentPipelineBoardPageSlots as ContentPipelineWorkspacePageSlots, ContentPipelinesPageSlots, ContentProcessingStatus, ContentProcessingStep, ContentReviewAction, ContentReviewCardProps, ContentSidebarMiddleProps, ContentSidebarProps, ContentStepPanel, ContentStepPanelMap, ContentStepResourceBinding, ContentVocabulary, ContentWorkspaceShellProps, ContentWorkspaceStartControls, ContentWorkspaceState, CropAspectOption, MyReviewQueuePanelProps, PayloadBodyProps, PostPreviewProps, PostPreviewSlide, ProcessingStateStripProps, RenderCropOptions, ReviewActionBarProps, ReviewMode, SelectedAssetStripProps, SlideAnalysisPanelProps, SourceAssetsPanelProps, StoredSlideAnalysis };