@fougere/admin 0.9.3-alpha.0 → 0.11.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fougere/admin",
-  "version": "0.9.3-alpha.0",
+  "version": "0.11.0-alpha.0",
   "description": "A back-office derived from what the app already says it hosts — a react-admin DataProvider over the Fougere wire.",
   "keywords": [
     "fougere",
@@ -31,13 +31,14 @@
   },
   "files": [
     "dist",
-    "src"
+    "src",
+    "template"
   ],
   "dependencies": {
     "@dagrejs/dagre": "^3.1.1",
-    "@fougere/app": "0.9.3-alpha.0",
-    "@fougere/core": "0.9.3-alpha.0",
-    "@fougere/schema": "0.9.3-alpha.0"
+    "@fougere/app": "0.11.0-alpha.0",
+    "@fougere/core": "0.11.0-alpha.0",
+    "@fougere/schema": "0.11.0-alpha.0"
   },
   "devDependencies": {
     "@mui/material": "^9.3.1",

package/src/{extensions.ts → AdminExtension.ts}

@@ -1,20 +1,9 @@
-/** Additive presentation changes over the model derived from `rpc.discover`. */
 import type { FormField, TableColumn } from '@fougere/app/client';
-import { capabilitiesOf, type AdminOperation, type AdminResource } from './resources.js';
-import { mergeAdminFacets, type AdminFacets } from './facets.js';
-
-export interface AdminFieldExtension {
-  /** Changes the fallback in every derived view of this field. */
-  label?: string;
-  /** Removes the field from derived tables, shows and forms. */
-  hidden?: boolean;
-}
-
-export interface AdminOperationExtension {
-  label?: string;
-  /** `false` explicitly removes a confirmation added by an earlier extension. */
-  confirm?: string | false;
-}
+import { type AdminOperation } from './AdminOperation.js';
+import { capabilitiesOf, type AdminResource } from './AdminResource.js';
+import { mergeAdminFacets, type AdminFacets } from './AdminFacets.js';
+import type { AdminFieldExtension } from './AdminFieldExtension.js';
+import type { AdminOperationExtension } from './AdminOperationExtension.js';
 
 export interface AdminExtension {
   /** Registration key from the card (`post`, not `Post`). */

package/src/AdminFacetRegistry.ts

@@ -0,0 +1,9 @@
+import type { EditorialFacet } from './EditorialFacet.js';
+import type { UsersFacet } from './UsersFacet.js';
+
+/** Open registry of the semantic projections renderers understand. */
+export interface AdminFacetRegistry {
+  editorial: EditorialFacet;
+  users: UsersFacet;
+  [facet: string]: unknown;
+}

package/src/AdminFacets.ts

@@ -0,0 +1,22 @@
+import { isObject } from '@fougere/schema';
+import type { AdminFacetRegistry } from './AdminFacetRegistry.js';
+
+export type AdminFacets = Partial<AdminFacetRegistry>;
+
+export function defineAdminFacet<const Name extends string, const Value>(
+  name: Name,
+  value: Value,
+): Record<Name, Value> {
+  return { [name]: value } as Record<Name, Value>;
+}
+
+/** Arrays replace; semantic objects merge recursively so small project deltas stay small. */
+export function mergeAdminFacets(base: AdminFacets, patch: AdminFacets): AdminFacets {
+  const merge = (left: unknown, right: unknown): unknown => {
+    if (!isObject(left) || !isObject(right)) return right;
+    const out: Record<string, unknown> = { ...left };
+    for (const [key, value] of Object.entries(right)) out[key] = merge(out[key], value);
+    return out;
+  };
+  return merge(base, patch) as AdminFacets;
+}

package/src/AdminFieldExtension.ts

@@ -0,0 +1,6 @@
+export interface AdminFieldExtension {
+  /** Changes the fallback in every derived view of this field. */
+  label?: string;
+  /** Removes the field from derived tables, shows and forms. */
+  hidden?: boolean;
+}

package/src/AdminOperation.ts

@@ -0,0 +1,9 @@
+import { type CardOp } from '@fougere/core/contract';
+
+/** One operation as the admin meets it, before a renderer decides its widget. */
+export interface AdminOperation extends CardOp {
+  /** Display fallback. An extension may replace it without renaming the call. */
+  label: string;
+  /** Optional confirmation sentence, interpreted by renderers that support actions. */
+  confirm?: string;
+}

package/src/AdminOperationExtension.ts

@@ -0,0 +1,5 @@
+export interface AdminOperationExtension {
+  label?: string;
+  /** `false` explicitly removes a confirmation added by an earlier extension. */
+  confirm?: string | false;
+}

package/src/{resources.ts → AdminResource.ts}

@@ -1,4 +1,3 @@
-/** What the app hosts, read as a back-office. */
 import { Card, FieldSet, type SchemaView } from '@fougere/schema';
 import {
   CALL_ENDPOINT,
@@ -10,19 +9,12 @@ import {
   type FormField,
   type TableColumn,
 } from '@fougere/app/client';
-import { type CardOp, type IdentityCard, Invocation } from '@fougere/core/contract';
-import type { ResourceKey } from './provider.js';
-import type { AdminFacets } from './facets.js';
+import { type IdentityCard, Invocation } from '@fougere/core/contract';
+import type { ResourceKey } from './ResourceKey.js';
+import type { AdminFacets } from './AdminFacets.js';
+import type { AdminOperation } from './AdminOperation.js';
 
-/** One operation as the admin meets it, before a renderer decides its widget. */
-export interface AdminOperation extends CardOp {
-  /** Display fallback. An extension may replace it without renaming the call. */
-  label: string;
-  /** Optional confirmation sentence, interpreted by renderers that support actions. */
-  confirm?: string;
-}
-
-/** One door, everything the UI needs to render it. */
+/** One facade, everything the UI needs to render it. */
 export interface AdminResource extends ResourceKey {
   /** The frond it belongs to — the menu groups by it, as the card does. */
   frond: string;
@@ -40,7 +32,7 @@ export interface AdminResource extends ResourceKey {
   /** Every callable operation, including the five CRUD verbs. */
   operations: AdminOperation[];
   /**
-   * Which of the five the door actually serves. A door answering only `list` gets a
+   * Which of the five the facade actually serves. A facade answering only `list` gets a
    * list and no buttons — the card says so, so the UI never offers what would 404.
    */
   can: { list: boolean; show: boolean; create: boolean; edit: boolean; delete: boolean };
@@ -52,12 +44,12 @@ function labelOf(name: string): string {
 }
 
 /**
- * The five verbs react-admin already has pages for. Everything else a door serves is a
+ * The five verbs react-admin already has pages for. Everything else a facade serves is a
  * business operation, and gets a button rather than a page.
  */
 export const CRUD_OPS = ['list', 'findById', 'create', 'update', 'delete'] as const;
 
-/** What a door serves beyond CRUD — the only thing this panel has that a generic one has not. */
+/** What a facade serves beyond CRUD — the only thing this panel has that a generic one has not. */
 export function actionsOf(operations: readonly AdminOperation[]): AdminOperation[] {
   return operations.filter((op) => !(CRUD_OPS as readonly string[]).includes(op.name));
 }
@@ -74,25 +66,25 @@ export function capabilitiesOf(operations: readonly Pick<AdminOperation, 'name'>
   };
 }
 
-/** A door with no schema is not a resource. */
+/** A facade with no schema is not a resource. */
 export function resourcesOf(card: IdentityCard): AdminResource[] {
   const out: AdminResource[] = [];
   for (const frond of card.fronds) {
-    for (const door of frond.doors) {
-      if (!door.schema) continue;
-      const entity = Card.fromDescriptor(door.schema).toSchema() as unknown as SchemaView;
+    for (const facade of frond.facades) {
+      if (!facade.schema) continue;
+      const entity = Card.fromDescriptor(facade.schema).toSchema() as unknown as SchemaView;
       const primary = FieldSet.of(entity.getFields()).primary;
       // No primary means no row identity — a list could be drawn, but nothing could be
       // opened, edited or deleted. Refusing here is the same answer `FieldSet.primary`
       // gives by not defaulting to 'id': the caller decides, and this caller declines.
       if (!primary) continue;
-      const operations = door.ops.map((op) => ({ ...op, label: labelOf(op.name) }));
-      const columns = tableColumnsOf(entity, door.name);
-      const fields = formFieldsOf(entity, door.name);
+      const operations = facade.ops.map((op) => ({ ...op, label: labelOf(op.name) }));
+      const columns = tableColumnsOf(entity, facade.name);
+      const fields = formFieldsOf(entity, facade.name);
       out.push({
-        name: door.name,
+        name: facade.name,
         frond: frond.name,
-        label: labelOf(door.name),
+        label: labelOf(facade.name),
         facets: {},
         primary,
         columns,
@@ -105,7 +97,7 @@ export function resourcesOf(card: IdentityCard): AdminResource[] {
   return out;
 }
 
-/** The provider's index — the half of a resource it needs, keyed by door name. */
+/** The provider's index — the half of a resource it needs, keyed by facade name. */
 export function keysOf(resources: AdminResource[]): Record<string, ResourceKey> {
   return Object.fromEntries(resources.map((r) => [r.name, { name: r.name, primary: r.primary }]));
 }

package/src/{runtime.ts → AdminRuntime.ts}

@@ -1,27 +1,9 @@
-/** One card request, shared by resource discovery and every provider operation. */
-import {
-  CALL_ENDPOINT,
-  fetcher as browserFetcher,
-  type Fetcher,
-} from '@fougere/app/client';
-import { applyAdminExtensions, type AdminExtension } from './extensions.js';
-import {
-  createDataProvider,
-  createLazyDataProvider,
-  type FougereDataProvider,
-} from './provider.js';
-import { fetchCard, keysOf, resourcesOf, type AdminResource } from './resources.js';
-
-export interface AdminRuntimeOptions {
-  endpoint?: string;
-  fetcher?: Fetcher;
-  extensions?: readonly AdminExtension[];
-}
-
-export interface LoadedAdmin {
-  resources: AdminResource[];
-  provider: FougereDataProvider;
-}
+import { CALL_ENDPOINT, fetcher as browserFetcher } from '@fougere/app/client';
+import { applyAdminExtensions } from './AdminExtension.js';
+import { createDataProvider, createLazyDataProvider, type FougereDataProvider } from './FougereDataProvider.js';
+import { fetchCard, keysOf, resourcesOf } from './AdminResource.js';
+import type { AdminRuntimeOptions } from './AdminRuntimeOptions.js';
+import type { LoadedAdmin } from './LoadedAdmin.js';
 
 export interface AdminRuntime {
   /** Loads and caches the card-derived model. */

package/src/AdminRuntimeOptions.ts

@@ -0,0 +1,8 @@
+import { fetcher as browserFetcher, type Fetcher } from '@fougere/app/client';
+import { type AdminExtension } from './AdminExtension.js';
+
+export interface AdminRuntimeOptions {
+  endpoint?: string;
+  fetcher?: Fetcher;
+  extensions?: readonly AdminExtension[];
+}

package/src/{topology.ts → Drawing.ts}

@@ -1,4 +1,3 @@
-/** How the system is arranged, as the app itself reports it. */
 import dagre from '@dagrejs/dagre';
 import {
   CALL_ENDPOINT,
@@ -6,16 +5,11 @@ import {
   sendCall,
   type Fetcher,
 } from '@fougere/app/client';
-import {
-  ErrorCode,
-  type DeclaredEdge,
-  type Edge,
-  type FrondPlacement,
-  type TopologyReport,
-  Invocation,
-} from '@fougere/core/contract';
-
-export type { TopologyReport, FrondPlacement, Edge, DeclaredEdge };
+import { ErrorCode, type FrondPlacement, type TopologyReport, Invocation } from '@fougere/core/contract';
+import type { TopologyNode } from './TopologyNode.js';
+import type { Point } from './Point.js';
+import type { PlacedNode } from './PlacedNode.js';
+import type { PlacedEdge } from './PlacedEdge.js';
 
 /** The report, or `undefined` when the app serves no topology at all. */
 export async function fetchTopology(
@@ -35,23 +29,6 @@ export async function fetchTopology(
   }
 }
 
-/** One frond as the page draws it: its placement, and the calls observed around it. */
-export interface TopologyNode extends FrondPlacement {
-  /** Fronds this one called, with what it cost them. */
-  calls: Edge[];
-  /** Fronds that called this one. */
-  calledBy: Edge[];
-  /** Fronds its code reaches, whether or not a call has ever gone down the link. */
-  declaredCalls: DeclaredEdge[];
-  /** Where the config says to reach it, when it says so. */
-  at?: string;
-  /**
-   * Declared in `remotes:` and never heard from. A different absence from an opaque remote,
-   * which answered and keeps its shape to itself: this one may simply be down.
-   */
-  silent: boolean;
-}
-
 /** The report read as a graph — what runs here first, then what answered, then what never did. */
 export function nodesOf(report: TopologyReport): TopologyNode[] {
   const order = { local: 0, remote: 1 };
@@ -83,7 +60,7 @@ export function nodesOf(report: TopologyReport): TopologyNode[] {
       frond: one.frond,
       placement: 'remote' as const,
       entities: 0,
-      doors: 0,
+      facades: 0,
       ...around(one.frond),
       ...(one.at ? { at: one.at } : {}),
       silent: true,
@@ -92,36 +69,6 @@ export function nodesOf(report: TopologyReport): TopologyNode[] {
   return [...heard, ...silent];
 }
 
-export interface Point {
-  x: number;
-  y: number;
-}
-
-/** A node placed on the drawing. `x`/`y` are its CENTRE, the convention the layout answers in. */
-export interface PlacedNode {
-  node: TopologyNode;
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-}
-
-/**
- * One link between two nodes. `count` is absent on a link nothing has travelled: the config
- * declares it and no call has gone down it, which is drawn broken rather than not drawn.
- */
-export interface PlacedEdge {
-  from: string;
-  to: string;
-  path: string;
-  /** Where this link's figure goes — clear of every node, or absent when the route is a point. */
-  at?: Point;
-  count?: number;
-  errors: number;
-  /** Where this link's volume sits among the others, `0` to `1`. Absent when nothing travelled. */
-  weight?: number;
-}
-
 export interface Drawing {
   nodes: PlacedNode[];
   edges: PlacedEdge[];
@@ -310,5 +257,5 @@ function labelAt(points: readonly Point[], boxes: readonly PlacedNode[], half: n
  * a frond that never answered has the same two zeroes and a different reason for them.
  */
 export function isOpaque(node: FrondPlacement): boolean {
-  return node.placement === 'remote' && node.entities === 0 && node.doors === 0;
+  return node.placement === 'remote' && node.entities === 0 && node.facades === 0;
 }

package/src/EditorialFacet.ts

@@ -0,0 +1,12 @@
+export interface EditorialFacet {
+  /** The field that carries the human-readable title. */
+  title: string;
+  /** The lifecycle vocabulary, grouped by meaning rather than by raw enum value. */
+  state?: {
+    field: string;
+    draft?: readonly string[];
+    published?: readonly string[];
+  };
+  createdAt?: string;
+  updatedAt?: string;
+}

package/src/FougereAdminProps.ts

@@ -0,0 +1,17 @@
+import type { AdminProps as BaseAdminProps } from 'react-admin';
+import type { FougereDashboardExtension } from './FougereDashboardExtension.js';
+import type { AdminExtension } from './AdminExtension.js';
+import type { Fetcher } from '@fougere/app/client';
+import type { ReactAdminRenderers } from './ReactAdminRenderers.js';
+import type { ReactAdminResourceComponents } from './ReactAdminResourceComponents.js';
+
+export type FougereAdminProps = Omit<BaseAdminProps, 'children' | 'dataProvider'> & {
+  endpoint?: string;
+  fetcher?: Fetcher;
+  extensions?: readonly AdminExtension[];
+  renderers?: ReactAdminRenderers;
+  /** Add, move, resize, replace or hide widgets without snapshotting the dashboard. */
+  dashboardExtensions?: readonly FougereDashboardExtension[];
+  /** Explicit page-level escape hatches, scoped to one resource and one view. */
+  resourceComponents?: Record<string, ReactAdminResourceComponents>;
+};

package/src/FougereDashboardContextValue.ts

@@ -0,0 +1,11 @@
+import type { FougereDashboardResource } from './FougereDashboardResource.js';
+import type { FougereDashboardMetrics } from './FougereDashboardMetrics.js';
+
+export interface FougereDashboardContextValue {
+  loading: boolean;
+  resources: FougereDashboardResource[];
+  editorial: FougereDashboardResource[];
+  users: FougereDashboardResource[];
+  metrics: FougereDashboardMetrics;
+  navigate(view: 'list' | 'show' | 'edit' | 'create', resource: string, id?: string | number): void;
+}

package/src/FougereDashboardExtension.ts

@@ -0,0 +1,13 @@
+import type { ComponentType } from 'react';
+import type { FougereDashboardZone } from './FougereDashboardZone.js';
+
+/** A delta over stable widget ids; a component on a new id contributes a new widget. */
+export interface FougereDashboardExtension {
+  widget: string;
+  component?: ComponentType;
+  zone?: FougereDashboardZone;
+  span?: number;
+  hidden?: boolean;
+  before?: string;
+  after?: string;
+}

package/src/FougereDashboardMetrics.ts

@@ -0,0 +1,6 @@
+export interface FougereDashboardMetrics {
+  content: number;
+  drafts: number;
+  published: number;
+  users: number;
+}

package/src/FougereDashboardResource.ts

@@ -0,0 +1,14 @@
+import type { AdminFacets } from './AdminFacets.js';
+
+export interface FougereDashboardResource {
+  name: string;
+  label: string;
+  primary: string;
+  facets: AdminFacets;
+  hasCreate: boolean;
+  hasEdit: boolean;
+  hasShow: boolean;
+  total: number;
+  rows: Record<string, unknown>[];
+  states: Record<string, number>;
+}

package/src/FougereDashboardWidget.ts

@@ -0,0 +1,11 @@
+import type { ComponentType } from 'react';
+import type { FougereDashboardZone } from './FougereDashboardZone.js';
+
+export interface FougereDashboardWidget {
+  id: string;
+  zone: FougereDashboardZone;
+  /** Twelve-column width for `main`, four-column width for `metrics`. */
+  span: number;
+  component: ComponentType;
+  hidden?: boolean;
+}

package/src/FougereDashboardZone.ts

@@ -0,0 +1 @@
+export type FougereDashboardZone = 'hero' | 'metrics' | 'main';

package/src/{provider.ts → FougereDataProvider.ts}

@@ -1,30 +1,7 @@
-/** react-admin's `DataProvider`, answered by the Fougere wire. */
-import {
-  sendCall,
-  fetcher as browserFetcher,
-  CALL_ENDPOINT,
-  itemsOf,
-  pageOf,
-  errorsByField,
-  type Fetcher,
-} from '@fougere/app/client';
+import { sendCall, fetcher as browserFetcher, CALL_ENDPOINT, itemsOf, pageOf, errorsByField } from '@fougere/app/client';
 import { validationErrorsOf } from '@fougere/core/contract';
-
-/** What a resource must tell the provider — the rest of the card is the UI's business. */
-export interface ResourceKey {
-  /** The registration key its door answers under — `post`, not `Post`. */
-  name: string;
-  /** The field that identifies an instance. */
-  primary: string;
-}
-
-export interface ProviderOptions {
-  /** Registration key → its identity. Built from the card by `resourcesOf`. */
-  resources: Record<string, ResourceKey>;
-  /** The call endpoint. A named surface appends `/{surface}` to it. */
-  endpoint?: string;
-  fetcher?: Fetcher;
-}
+import type { ResourceKey } from './ResourceKey.js';
+import type { ProviderOptions } from './ProviderOptions.js';
 
 type Values = Record<string, unknown>;
 

package/src/FougereResourceOptions.ts

@@ -0,0 +1,13 @@
+import type { ResourceOptions } from 'react-admin';
+import type { AdminFacets } from './AdminFacets.js';
+
+export interface FougereResourceOptions extends ResourceOptions {
+  primary: string;
+  facets: AdminFacets;
+  /** The frond that owns this facade — the card groups by it, so the panel can too. */
+  frond?: string;
+  /** What the facade answers, with each op's kind. `query` reads, `command` writes. */
+  operations?: readonly { name: string; kind: 'query' | 'command' }[];
+  /** How many columns the shape yields — a rough measure of an entity's width. */
+  fieldCount?: number;
+}

package/src/LoadedAdmin.ts

@@ -0,0 +1,7 @@
+import { type FougereDataProvider } from './FougereDataProvider.js';
+import { type AdminResource } from './AdminResource.js';
+
+export interface LoadedAdmin {
+  resources: AdminResource[];
+  provider: FougereDataProvider;
+}

package/src/PlacedEdge.ts

@@ -0,0 +1,17 @@
+import type { Point } from './Point.js';
+
+/**
+ * One link between two nodes. `count` is absent on a link nothing has travelled: the config
+ * declares it and no call has gone down it, which is drawn broken rather than not drawn.
+ */
+export interface PlacedEdge {
+  from: string;
+  to: string;
+  path: string;
+  /** Where this link's figure goes — clear of every node, or absent when the route is a point. */
+  at?: Point;
+  count?: number;
+  errors: number;
+  /** Where this link's volume sits among the others, `0` to `1`. Absent when nothing travelled. */
+  weight?: number;
+}

package/src/PlacedNode.ts

@@ -0,0 +1,10 @@
+import type { TopologyNode } from './TopologyNode.js';
+
+/** A node placed on the drawing. `x`/`y` are its CENTRE, the convention the layout answers in. */
+export interface PlacedNode {
+  node: TopologyNode;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}

package/src/Point.ts

@@ -0,0 +1,4 @@
+export interface Point {
+  x: number;
+  y: number;
+}

package/src/ProviderOptions.ts

@@ -0,0 +1,10 @@
+import { fetcher as browserFetcher, type Fetcher } from '@fougere/app/client';
+import type { ResourceKey } from './ResourceKey.js';
+
+export interface ProviderOptions {
+  /** Registration key → its identity. Built from the card by `resourcesOf`. */
+  resources: Record<string, ResourceKey>;
+  /** The call endpoint. A named surface appends `/{surface}` to it. */
+  endpoint?: string;
+  fetcher?: Fetcher;
+}

package/src/ReactAdminFieldContext.ts

@@ -0,0 +1,10 @@
+import { type ReactElement } from 'react';
+import { type AdminResource } from './AdminResource.js';
+import { type TableColumn } from '@fougere/app/client';
+
+export interface ReactAdminFieldContext {
+  resource: AdminResource;
+  column: TableColumn;
+  /** The maintained Fougere renderer. Call it to wrap rather than replace it. */
+  defaultRender(): ReactElement;
+}

package/src/ReactAdminFieldRenderer.ts

@@ -0,0 +1,4 @@
+import { type ReactElement } from 'react';
+import type { ReactAdminFieldContext } from './ReactAdminFieldContext.js';
+
+export type ReactAdminFieldRenderer = (context: ReactAdminFieldContext) => ReactElement;

package/src/ReactAdminInputContext.ts

@@ -0,0 +1,9 @@
+import { type ReactElement } from 'react';
+import { type AdminResource } from './AdminResource.js';
+import { type FormField } from '@fougere/app/client';
+
+export interface ReactAdminInputContext {
+  resource: AdminResource;
+  field: FormField;
+  defaultRender(): ReactElement;
+}

package/src/ReactAdminInputRenderer.ts

@@ -0,0 +1,4 @@
+import { type ReactElement } from 'react';
+import type { ReactAdminInputContext } from './ReactAdminInputContext.js';
+
+export type ReactAdminInputRenderer = (context: ReactAdminInputContext) => ReactElement;

package/src/ReactAdminRenderers.ts

@@ -0,0 +1,8 @@
+import type { ReactAdminFieldRenderer } from './ReactAdminFieldRenderer.js';
+import type { ReactAdminInputRenderer } from './ReactAdminInputRenderer.js';
+
+export interface ReactAdminRenderers {
+  /** Exact `resource.field` keys. Unmentioned and future fields keep the default renderer. */
+  fields?: Record<string, ReactAdminFieldRenderer>;
+  inputs?: Record<string, ReactAdminInputRenderer>;
+}

package/src/ReactAdminResourceComponents.ts

@@ -0,0 +1,9 @@
+import { type ComponentType } from 'react';
+
+export interface ReactAdminResourceComponents {
+  list?: ComponentType;
+  show?: ComponentType;
+  edit?: ComponentType;
+  create?: ComponentType;
+  icon?: ComponentType;
+}

package/src/ResourceKey.ts

@@ -0,0 +1,7 @@
+/** What a resource must tell the provider — the rest of the card is the UI's business. */
+export interface ResourceKey {
+  /** The registration key its facade answers under — `post`, not `Post`. */
+  name: string;
+  /** The field that identifies an instance. */
+  primary: string;
+}

package/src/ResourceRenderOptions.ts

@@ -0,0 +1,7 @@
+import type { ReactAdminRenderers } from './ReactAdminRenderers.js';
+import type { ReactAdminResourceComponents } from './ReactAdminResourceComponents.js';
+
+export interface ResourceRenderOptions {
+  renderers?: ReactAdminRenderers;
+  components?: ReactAdminResourceComponents;
+}