@wildo-ai/saas-frontend-lib 1.0.1

package/dist/esm/core/resources/resources.frontend.schemas.d.ts

@@ -0,0 +1,960 @@
+import type React from 'react';
+import { z } from "zod";
+import type { EnumLikeType, IconLike, AutosaveFieldParams, ValidationMode, ResponsiveAware, EditChromeMode, DisplayChromeMode, DraftableConfigParams } from '@wildo-ai/zod-decorators';
+import type { QuickSwitcherScopeField } from '../../core/config/app-configuration-frontend.schemas.js';
+import { ResourceParentResourceRequirement, ResourcePrimaryScope, ResourceRelationship, ResourceTranspositionPolicy, CoreResourceOperation, ResourceFieldIdentifier, ResourceType, ResourceConfiguration_Operation_ApiCall, ResourceConfiguration_Operation_ApiCallWithCallback, ResourceConfiguration_ResourceRelationships, ResourceConfiguration_InheritanceSchemaDefinition, TourStepPlacement, NavigationZoneName, OverlayAppearance, SplitAppearance } from '@wildo-ai/saas-models';
+import type { ResourceConfiguration, ResourceConfiguration_InitializationFactory, ValidOperationKeys, RelationshipDisplayInParentView, RelationshipDisplayInParentNavigation, RelationshipDisplayInChildView } from '@wildo-ai/saas-models';
+import type { InsertedChartDeclaration } from '../../core/config/chart-view.frontend.schemas.js';
+import type { InsertedExecutionDeclaration, ResourceExecutionViewsConfig } from '../../core/config/execution-view.schemas.js';
+import type { OnboardingElementType, GuidanceRenderMode, GuidanceFlowScope, GuidanceAudience, NotificationBadgeDefinition, UserNotificationDefinition, SubtreeMap } from '@wildo-ai/saas-models';
+import { ViewportBreakpoint } from '@wildo-ai/zod-decorators';
+import type { CompositeViewComponentProps, InsertedCompositeDeclaration } from '../config/composite-view.schemas.js';
+export declare const NavigationOperationOverrideSchema: z.ZodObject<{
+    transition: z.ZodUnion<readonly [z.ZodEnum<typeof import("@wildo-ai/saas-models").NavigationTransition>, z.ZodObject<{
+        transition: z.ZodEnum<typeof import("@wildo-ai/saas-models").NavigationTransition>;
+        persistent: z.ZodOptional<z.ZodBoolean>;
+        ephemeral: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip, core.$ZodObjectExtra>]>;
+    appearance: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEnum<typeof OverlayAppearance>, z.ZodEnum<typeof SplitAppearance>]>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodUnion<readonly [z.ZodEnum<typeof OverlayAppearance>, z.ZodEnum<typeof SplitAppearance>]>>]>>;
+    fromZone: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof NavigationZoneName>, z.ZodLiteral<"appLevel">]>>;
+    viewport: z.ZodOptional<z.ZodEnum<typeof ViewportBreakpoint>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type NavigationOperationOverride = z.infer<typeof NavigationOperationOverrideSchema>;
+/**
+ * Runtime-resolved scope field definition.
+ *
+ * Extends the config-declared `QuickSwitcherScopeField` (from top-level
+ * `appScope.fields`) with properties resolved at initialization time from the
+ * resource registry.
+ *
+ * Created by AppScopeContext from the `appScope.fields` configuration.
+ */
+export interface AppScopeFieldDefinition extends QuickSwitcherScopeField {
+    /** Resolved from the resource configuration at initialization */
+    resourcePrimaryScope: ResourcePrimaryScope;
+}
+import type { FrontendResourceOperationPath, FrontendResource_ParentResourceRequirement } from './resource-path.frontend.schemas.js';
+type FrontendResourceOperation_Base = {
+    /**
+     * Frontend UI behavior config for this operation. `undefined` for API-only
+     * operations that have no UI presence (callable via httpClient but not
+     * surfaced in preset-driven UI). Operations with a preset entry always have
+     * a defined value.
+     */
+    operationFrontendConfig?: ResourceOperationFrontendConfig;
+};
+export type FrontendResourceConfiguration_Operation<TCustomOperationEnum extends EnumLikeType | undefined = any, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined = any, TMainSchema extends z.ZodTypeAny = z.ZodAny> = (ResourceConfiguration_Operation_ApiCall<TCustomOperationEnum, TCoreOperationEnum, TMainSchema> | ResourceConfiguration_Operation_ApiCallWithCallback<TCustomOperationEnum, TCoreOperationEnum, TMainSchema>) & FrontendResourceOperation_Base;
+export type FrontendResourceConfiguration<TCustomOperationEnum extends EnumLikeType | undefined = any, TCoreOperationEnum extends Partial<CoreResourceOperation> | undefined = any, TMainSchema extends z.ZodTypeAny = z.ZodAny> = {
+    isDisabled: boolean;
+    resourcePrimaryScope: ResourcePrimaryScope;
+    resourceIdentifier: ResourceType;
+    resourceFieldIdentifier: ResourceFieldIdentifier;
+    coreOperations: TCoreOperationEnum[];
+    customOperation?: TCustomOperationEnum;
+    mainSchema: TMainSchema;
+    resourceRelationships: ResourceConfiguration_ResourceRelationships;
+    inheritenceSchemaDefinition?: ResourceConfiguration_InheritanceSchemaDefinition<EnumLikeType, TMainSchema>;
+    frontendConfiguration?: ResourceUIBehaviorResourceLevelConfig<TCustomOperationEnum, TCoreOperationEnum, TMainSchema>;
+    isSystemResource: boolean;
+    isAnonymizable: boolean;
+    transpositionPolicy: ResourceTranspositionPolicy;
+    operations: FrontendResourceConfiguration_Operation<TCustomOperationEnum, TCoreOperationEnum, TMainSchema>[];
+};
+export type AnyFrontendResourceConfiguration = FrontendResourceConfiguration<any, any, any>;
+export type FrontendResourcesRegistry = {
+    allResourceFieldIdentifiers: Record<string, string>;
+    fieldIdentifierToResourceType: Record<string, ResourceType>;
+    notificationBadgeDefinitions: NotificationBadgeDefinition[];
+    additionalUserNotificationDefinitions: UserNotificationDefinition[];
+    resourceRelationships: ResourceRelationship[];
+    resourceConfigurations: {
+        [key: ResourceType]: AnyFrontendResourceConfiguration;
+    };
+    subtreeMap: SubtreeMap;
+};
+/** ──────────────────────────────────────────────────────────────
+ * FrontendResourceOperationContext
+ *
+ * Explicit interface for proper TypeScript typing.
+ * The operation field uses FrontendResourceConfiguration_Operation type.
+ * ────────────────────────────────────────────────────────────── */
+export interface FrontendResourceOperationContext extends FrontendResourceOperationPath {
+    /** Current operation being executed */
+    resourceType: string;
+    /** The operation configuration - properly typed */
+    operation: FrontendResourceConfiguration_Operation;
+    /** Resource context map: ResourceType -> resourceId | {fieldIdentifier, resourceId} */
+    contextResourceIdentifiers: Record<string, string | {
+        fieldIdentifier: string;
+        resourceId: string;
+    }>;
+    /** Additional context data that can be passed */
+    additionalContext?: Record<string, unknown>;
+    /** Parent resource requirements - explicitly included from FrontendResourceOperationPath */
+    parentResourcesRequirements: FrontendResource_ParentResourceRequirement[];
+}
+/** ──────────────────────────────────────────────────────────────
+ * Internal Schemas (concrete, for method access)
+ * ────────────────────────────────────────────────────────────── */
+export declare const FrontendResourceOperationContextSchema: z.ZodObject<{
+    resourceType: z.ZodString;
+    parentResourcesRequirements: z.ZodArray<z.ZodObject<{
+        resourceType: z.ZodUnion<readonly [z.ZodEnum<typeof import("@wildo-ai/saas-models").CoreResourceType>, z.ZodString]>;
+        foreignKeyField: z.ZodOptional<z.ZodString>;
+        childResourceType: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof import("@wildo-ai/saas-models").CoreResourceType>, z.ZodString]>>;
+        relationshipEdgeKey: z.ZodOptional<z.ZodString>;
+        requirement: z.ZodEnum<typeof ResourceParentResourceRequirement>;
+        isPrimaryScope: z.ZodBoolean;
+        primaryScope: z.ZodOptional<z.ZodEnum<typeof ResourcePrimaryScope>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    operationIdentifier: z.ZodString;
+    isOperationDefault: z.ZodBoolean;
+    isBulkOperation: z.ZodBoolean;
+    variantKey: z.ZodOptional<z.ZodString>;
+    operation: z.ZodAny;
+    contextResourceIdentifiers: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        fieldIdentifier: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip, core.$ZodObjectExtra>]>>;
+    additionalContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+/**
+ * Frontend-native resource configuration types.
+ *
+ * Defines the complete frontend configuration for resources and their operations,
+ * independent of app type. This replaces the legacy per-app discriminated
+ * `ResourceOperationFrontendConfig`.
+ *
+ * The resource-level fields (labels, sections, views, empty state, guidance) are
+ * written to `FrontendResourceConfiguration.frontendConfiguration` during registry
+ * build. The `views` sub-field provides per-operation frontend config — giving
+ * a single, self-contained definition of how each resource appears and behaves in
+ * a given frontend application.
+ */
+/** Secondary action type for empty state (link to URL vs guidance flow). */
+export declare enum ResourceFrontend_EmptyStateSecondaryActionType {
+    LINK = "link",
+    GUIDANCE = "guidance"
+}
+/** Trigger type for resource-level guidance flows. */
+export declare enum ResourceFrontend_GuidanceFlowTriggerType {
+    FIRST_VISIT = "FIRST_VISIT",
+    MANUAL = "MANUAL",
+    DELAYED = "DELAYED",
+    EVENT = "EVENT"
+}
+/**
+ * Empty state configuration for list/table views when no items exist.
+ * Labels (title, description, primaryActionLabel) come from i18n.
+ *
+ * @example
+ * ```
+ * emptyState: {
+ *   icon: 'inbox',
+ *   primaryAction: CoreResourceOperation.CREATE,
+ *   secondaryAction: { type: ResourceFrontend_EmptyStateSecondaryActionType.LINK, target: 'https://docs.example.com/projects' },
+ * }
+ * ```
+ */
+export interface ResourceUIBehavior_EmptyState {
+    /** Icon ref from the icon registry. If not provided, uses a default empty-state icon. */
+    icon?: string;
+    /**
+     * Operation ref for the primary CTA (e.g., `CoreResourceOperation.CREATE`).
+     * If not provided, auto-detects CREATE from available operations.
+     * Set to `false` to explicitly disable the primary action button.
+     */
+    primaryAction?: string | false;
+    /** Secondary action — link to docs, guidance flow, or external URL. */
+    secondaryAction?: {
+        type: ResourceFrontend_EmptyStateSecondaryActionType;
+        target: string;
+    };
+}
+/**
+ * Single guidance element within a resource-level guidance flow.
+ * Maps to an OnboardingElement during compilation.
+ */
+export interface ResourceFrontend_GuidanceElement {
+    type: OnboardingElementType;
+    ref: string;
+    targetField?: string;
+    targetSelector?: string;
+    placement?: TourStepPlacement;
+    actionRef?: string;
+    steps?: Array<{
+        ref: string;
+        targetField?: string;
+        targetSelector?: string;
+        placement?: TourStepPlacement;
+    }>;
+    questions?: Array<{
+        id: string;
+        type: string;
+        required?: boolean;
+        options?: Array<{
+            ref: string;
+            value?: string;
+        }>;
+    }>;
+}
+/**
+ * Resource-level guidance flow declaration.
+ * Compiled into a standard `GuidanceFlowDefinition` by the guidance-resource-compiler.
+ */
+export interface ResourceUIBehavior_GuidanceFlow {
+    ref: string;
+    bindToOperation: string;
+    renderMode: GuidanceRenderMode;
+    trigger: {
+        type: ResourceFrontend_GuidanceFlowTriggerType;
+        delayMs?: number;
+        eventName?: string;
+    };
+    scope?: GuidanceFlowScope;
+    audience?: GuidanceAudience;
+    priority?: number;
+    elements: ResourceFrontend_GuidanceElement[];
+}
+/**
+ * Key identifying a resource operation in the frontend preset.
+ *
+ * - `string` — default operation (e.g., `CoreResourceOperation.READ`)
+ * - `readonly [string, string]` — non-default variant: `[operationIdentifier, variantKey]`
+ *   (e.g., `[CoreResourceOperation.READ, 'admin']`)
+ */
+export type OperationKey = string | readonly [string, string];
+/**
+ * Symbol key used internally by `resourceUIBehavior()` to attach the schema
+ * reference to the config object, and by `buildFrontendResourceConfigurations()`
+ * to extract it. Using a Symbol prevents collision with user-defined properties
+ * and is invisible in Object.keys()/JSON serialization.
+ */
+export declare const FRONTEND_SCHEMA_KEY: unique symbol;
+/** Extracts the typed shape from a ZodObject, falls back to Record for non-objects. */
+export type ObjectShape<T extends z.ZodTypeAny> = T extends z.ZodObject<infer S> ? S : Record<string, z.ZodTypeAny>;
+/**
+ * Accepts both factory functions and configuration instances for type inference.
+ * Used by `resourceUIBehavior()` to infer generics from either form.
+ */
+export type ResourceConfigLike<TCustomOp extends EnumLikeType | undefined, TCoreOp extends Partial<CoreResourceOperation> | undefined, TSchema extends z.ZodTypeAny> = ResourceConfiguration<TCustomOp, TCoreOp, TSchema> | ResourceConfiguration_InitializationFactory<TCustomOp, TCoreOp, TSchema>;
+/**
+ * Typed operation key — extends `ValidOperationKeys` with variant tuple support.
+ * When both generics default to `any`, collapses to `any` — backward compatible
+ * with untyped `OperationKey` usage.
+ */
+export type TypedOperationKey<TCustomOp extends EnumLikeType | undefined = any, TCoreOp extends Partial<CoreResourceOperation> | undefined = any> = ValidOperationKeys<TCustomOp, TCoreOp> | readonly [ValidOperationKeys<TCustomOp, TCoreOp>, string];
+/**
+ * Frontend configuration for a single resource operation.
+ *
+ * Controls how the operation is surfaced in the frontend:
+ * - `isAddressable` — whether the operation has a routable URL
+ * - `customView` — direct UIBehavior-owned React component override for authored custom operation views
+ *   Use the exported operation-family component types (`ResourceReadCustomViewComponent`,
+ *   `ResourceListCustomViewComponent`, etc.) plus the matching
+ *   `useReadOperationSurface()` / `useListOperationSurface()` helpers when you
+ *   want a strongly truthful custom host for a specific layout family.
+ * - `additionalViewLinks` — ordered refs of resource-owned chart/composite/execution
+ *   views that this operation host should surface
+ * - `displayPresetOverride` — layout preset override for the operation's UI
+ * - `navigationOverrides` — per-operation navigation transition overrides
+ * - `displayPriority` — visual ordering in ActionBar/operation lists (lower = higher priority)
+ * - `iconOverride` — per-operation icon ref (overrides resource-level icon in navigation items)
+ */
+export declare const ResourceOperationFrontendConfigSchema: z.ZodObject<{
+    isAddressable: z.ZodBoolean;
+    customView: z.ZodOptional<z.ZodAny>;
+    additionalViewLinks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    displayPresetOverride: z.ZodOptional<z.ZodObject<{
+        resourceLayoutPresetKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    navigationOverrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        transition: z.ZodUnion<readonly [z.ZodEnum<typeof import("@wildo-ai/saas-models").NavigationTransition>, z.ZodObject<{
+            transition: z.ZodEnum<typeof import("@wildo-ai/saas-models").NavigationTransition>;
+            persistent: z.ZodOptional<z.ZodBoolean>;
+            ephemeral: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip, core.$ZodObjectExtra>]>;
+        appearance: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEnum<typeof OverlayAppearance>, z.ZodEnum<typeof SplitAppearance>]>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodUnion<readonly [z.ZodEnum<typeof OverlayAppearance>, z.ZodEnum<typeof SplitAppearance>]>>]>>;
+        fromZone: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof NavigationZoneName>, z.ZodLiteral<"appLevel">]>>;
+        viewport: z.ZodOptional<z.ZodEnum<typeof ViewportBreakpoint>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>>;
+    displayPriority: z.ZodOptional<z.ZodNumber>;
+    iconOverride: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+/**
+ * TypeScript interface for `ResourceOperationFrontendConfigSchema`.
+ * `iconOverride` and `customView` are typed with React/function values
+ * even though the Zod schema uses `z.any()` — Zod cannot validate function types.
+ */
+export type ResourceOperationFrontendConfig = Omit<z.infer<typeof ResourceOperationFrontendConfigSchema>, 'iconOverride' | 'customView'> & {
+    iconOverride?: IconLike;
+    customView?: React.ComponentType;
+};
+export type ResourceCompositeViewsConfig = Record<string, React.ComponentType<CompositeViewComponentProps>>;
+/**
+ * Parameters passed to `getFrontendResourceLabel` functions.
+ *
+ * Generic `TMainSchema` defaults to `z.ZodAny` — presets and records use the
+ * default (giving `currentObject: any`), while app-level configs can narrow it
+ * to a concrete schema for type-safe field access.
+ */
+export type ResourceUIBehaviorLabelParams<TMainSchema extends z.ZodTypeAny = z.ZodAny> = {
+    currentObject: z.infer<TMainSchema>;
+    objectContext: any;
+    initiatorUserContext?: any;
+    t: (toTranslate: string, params?: Record<string, any>) => string;
+};
+/**
+ * Static manifest of structural refs used in JSX templates.
+ * Readable by the companion without JSX/AST parsing.
+ *
+ * Produces i18n keys:
+ * - `resources.{type}.sections.{ref}.title`
+ * - `resources.{type}.sections.{ref}.description`
+ * - `resources.{type}.wizardSteps.{ref}.title`
+ * - `resources.{type}.wizardSteps.{ref}.description`
+ * - `resources.{type}.groups.{ref}.title`
+ */
+export interface LayoutRefManifest {
+    /** Section names used in `<Section name="...">` components. */
+    sections?: string[];
+    /** Wizard step names used in `<WizardStep name="...">` components. */
+    wizardSteps?: string[];
+    /** Group names used in `<Group name="...">` components. */
+    groups?: string[];
+}
+/**
+ * Layout template — a React component rendered inside the appropriate provider stack.
+ *
+ * - Edit context: rendered inside `<Form>` providers. Use `useFormTemplateContext()` for
+ *   labels/schema/operation and `useWatch()` for field-reactive branching.
+ * - Display context: rendered inside `<DisplayTemplateProvider>` by `AutomaticDisplayer`.
+ *   Use `useDisplayTemplateContext()` for `data`, `isLoading`, `schema`, labels, and breakpoint.
+ * - Summary context: same as display, rendered by `ResourceSummaryDisplayer` with
+ *   `disableInlineEdit={true}` and compact chrome (INLINE default).
+ */
+export type LayoutTemplate = React.ComponentType;
+/**
+ * Resource layout configuration — template-based layout for forms and displays.
+ *
+ * Templates use skeleton components (`<FormField>`, `<Section>`,
+ * `<WizardLayout>`, `<DisplayField>`, etc.) with Tailwind CSS for positioning.
+ * Conditional visibility is handled with `useWatch()` and standard React conditionals.
+ *
+ * When no template is provided for a context, the framework generates a
+ * default flat template at runtime from the schema.
+ */
+export interface ResourceLayoutConfig {
+    /**
+     * Companion-readable manifest of all structural names used in templates.
+     * Required for i18n label generation.
+     * Dev-time validation cross-checks manifest names against template `name` props.
+     */
+    refs?: LayoutRefManifest;
+    /**
+     * Default chrome mode for fields in each context.
+     * Used when a field's `{primitive}UI.{context}.chromeMode` is not set.
+     * Renderers read: `{primitive}UI.{context}.chromeMode ?? layout.defaultChromeMode.{context} ?? system-default`
+     */
+    defaultChromeMode?: {
+        /** Default chrome for display context. */
+        display?: ResponsiveAware<DisplayChromeMode>;
+        /** Default chrome for summary context. */
+        summary?: ResponsiveAware<DisplayChromeMode>;
+        /** Default chrome for edit context. */
+        edit?: ResponsiveAware<EditChromeMode>;
+    };
+    /**
+     * Edit layout template — a `React.ComponentType` rendered inside `<Form>` providers.
+     * The component is instantiated as `<EditTemplate />` and has access to
+     * `useFormTemplateContext()` for labels/schema/operation and `useWatch()` for reactivity.
+     * For operation-specific branching, read `operationType` from `FormTemplateContext`.
+     * Standard `<FormField name="...">` slots automatically honor upstream
+     * generated replacements (for example relationship-backed fields reshaped by
+     * `ResourceAutomatedForm`). When a generated override exists, that replacement
+     * node owns its own chrome and ignores extra `FormField`-style props passed at
+     * the template slot.
+     */
+    edit?: LayoutTemplate;
+    /**
+     * Display layout template — rendered for read-only detail views.
+     * The component is instantiated inside `<DisplayTemplateProvider>` and has access to
+     * `useDisplayTemplateContext()` for `data`, `isLoading`, `variant`, labels, and breakpoint.
+     */
+    display?: LayoutTemplate;
+    /**
+     * Summary layout template — rendered for cards, list items, FK references.
+     * Typically a compact single-line or small card layout.
+     * The component is instantiated inside `<DisplayTemplateProvider>` by `ResourceSummaryDisplayer`,
+     * with `disableInlineEdit={true}` and chrome defaulting to `DisplayChromeMode.INLINE`.
+     * Use `useDisplayTemplateContext()` for reactive data access.
+     */
+    summary?: LayoutTemplate;
+}
+/**
+ * Per-relationship display override declared on the **owning resource's** preset.
+ *
+ * Each entry targets a specific relationship by `target` resource type (and
+ * optionally `foreignKeyField` for disambiguation when multiple relationships
+ * exist to the same type). The `inParentView` / `inParentNavigation` /
+ * `inChildView` sub-objects are shallow-merged onto the relationship's shared
+ * `display` config during registry build — frontend values win over shared defaults.
+ *
+ * **Ownership principle**: each resource configures its own view:
+ * - `inParentView` → "how does this child appear **in my view** when I'm the parent?"
+ * - `inParentNavigation` → "how does navigation from **my view** to this child behave?"
+ * - `inChildView` → "how does the parent reference appear **in my view** when I'm the child?"
+ *
+ * @example
+ * ```ts
+ * relationshipOverrides: [
+ *   // I'm parent of TASKS — make Tasks appear as accordion in MY view
+ *   { target: ResourceType.TASKS,
+ *     inParentView: { contentSectionConfig: { mode: SectionMode.ACCORDION } } },
+ *   // I'm child of USERS (FK: assignedToUserId) — show user as badge in MY view
+ *   { target: ResourceType.USERS, foreignKeyField: 'assignedToUserId',
+ *     inChildView: { parentDisplay: ParentDisplay.BADGE } },
+ * ]
+ * ```
+ */
+export interface RelationshipDisplayOverride {
+    /** Related resource type to match against. */
+    target: string;
+    /**
+     * FK field name for disambiguation when multiple relationships exist to the
+     * same `target` type. Matches against both explicit `rel.foreignKeyField` and
+     * implied FK from `allResourceFieldIdentifiers`.
+     */
+    foreignKeyField?: string;
+    /** Override for how children appear in THIS resource's view (when I'm parent). */
+    inParentView?: Partial<RelationshipDisplayInParentView>;
+    /** Override for how navigation from THIS resource's view to the child behaves. */
+    inParentNavigation?: Partial<RelationshipDisplayInParentNavigation>;
+    /** Override for how parent reference appears in THIS resource's view (when I'm child). */
+    inChildView?: Partial<RelationshipDisplayInChildView>;
+}
+/**
+ * Complete frontend configuration for a single resource within an application.
+ *
+ * Canonical frontend resource configuration type. Contains resource-level settings
+ * (labels, sections, views, empty state, guidance) plus per-operation frontend config.
+ *
+ * Generic `TMainSchema` defaults to `z.ZodAny`. Presets and `ResourceUIBehavior`
+ * records use the default; app-level configs can narrow it to a concrete schema
+ * for type-safe `getFrontendResourceLabel` callbacks.
+ *
+ * This is the canonical frontend type — it is self-contained and does not
+ * reference or depend on backend resource configuration factories.
+ *
+ * UI views use a `Map` keyed by `OperationKey`:
+ * - `string` key for default operations
+ * - `[operationId, variantKey]` tuple for non-default variants
+ *
+ * @example
+ * ```
+ * const orgConfig: ResourceUIBehaviorConfig<any, any, typeof OrgSchema> = {
+ *   getFrontendResourceLabel: ({ currentObject }) => currentObject.name, // type-safe
+ *   views: new Map([
+ *     [CoreResourceOperation.CREATE, { isAddressable: false }],
+ *     [CoreResourceOperation.LIST, { isAddressable: true }],
+ *   ]),
+ * };
+ *
+ * // Input form (via resourceUIBehavior callback) uses array-of-tuples:
+ * // views: [
+ * //   [CoreResourceOperation.CREATE, { isAddressable: false }],
+ * //   [CoreResourceOperation.LIST, { isAddressable: true }],
+ * // ],
+ * ```
+ */
+export type ResourceUIBehaviorConfig<TCustomOp extends EnumLikeType | undefined = any, TCoreOp extends Partial<CoreResourceOperation> | undefined = any, TMainSchema extends z.ZodTypeAny = z.ZodAny> = {
+    /**
+     * Resource-level icon — React component (e.g., Lucide) or string
+     * (StandardIconReference). Registered into `IconRegistry.resources`
+     * during `buildFrontendResourceConfigurations()`.
+     */
+    icon?: IconLike;
+    /**
+     * Per-field decorator overrides for the resource's `mainSchema`.
+     *
+     * Keys are field names of `TMainSchema`; values are decorated Zod schemas
+     * from the same shape (e.g., `shape.status.enumUI({ ... })`).
+     *
+     * The merge happens at **module evaluation time** — calling `.enumUI()`
+     * on a shape field mutates its metadata in place via `applySingleDecorator`
+     * merge semantics. Schema-level decorators are preserved, addon decorators
+     * overlay. No explicit runtime consumption is needed; the `fields`
+     * field exists primarily for type safety (`keyof z.infer<TMainSchema>`)
+     * and as a declaration container.
+     *
+     * @example
+     * ```ts
+     * fields: {
+     *   status: shape.status.enumUI({
+     *     values: { pending: { color: 'secondary' }, completed: { color: 'success' } },
+     *   }),
+     * }
+     * ```
+     */
+    fields?: {
+        [K in keyof ObjectShape<TMainSchema>]?: ObjectShape<TMainSchema>[K];
+    };
+    /**
+     * Resource-level default validation mode for form fields.
+     * Individual fields can override via `{primitive}UI({ edit: { validationMode } })`.
+     * Falls back to framework default (`ON_BLUR`) when not set.
+     */
+    defaultValidationMode?: ValidationMode;
+    /**
+     * Resource-level default autosave config for form fields.
+     * Individual fields can override via `{primitive}UI({ edit: { autosave } })`.
+     * When not set, autosave is disabled unless explicitly configured per-field.
+     */
+    defaultAutosave?: AutosaveFieldParams | true;
+    /**
+     * Resource-level draft mode configuration.
+     * Defines how draft/publish discrimination works — which field acts as
+     * discriminator, what values mean "draft" vs "published", and whether
+     * publishing requires confirmation.
+     *
+     * Consumed by `ResourceAutomatedForm` to enable Save-as-Draft / Publish
+     * buttons and relaxed validation for draft saves.
+     */
+    draftableConfig?: DraftableConfigParams;
+    /**
+     * Template-based layout configuration. Resources needing sections, wizard steps,
+     * or custom layouts provide explicit JSX templates using skeleton components
+     * (`<Section>`, `<FormField>`, `<WizardLayout>`, etc.).
+     *
+     * @see ResourceLayoutConfig
+     */
+    layout?: ResourceLayoutConfig;
+    /**
+     * Label generation for resource instances in the frontend.
+     *
+     * Can be either:
+     * - `string[]` — array of field paths to concatenate
+     * - `(params: ResourceUIBehaviorLabelParams) => string` — a function
+     *
+     * Used by `ResourceLayout_Header` to render the resource title.
+     */
+    getFrontendResourceLabel?: string[] | ((params: ResourceUIBehaviorLabelParams<TMainSchema>) => string);
+    /** Resource-owned composite templates declared inline on the resource UI behavior. */
+    compositeViews?: ResourceCompositeViewsConfig;
+    /** Resource-owned execution surfaces declared inline on the resource UI behavior. */
+    executionViews?: ResourceExecutionViewsConfig;
+    /** Resource-owned inserted chart declarations for this resource. */
+    chartViews?: InsertedChartDeclaration[];
+    /**
+     * Empty state configuration for list/table views when no items exist.
+     * Labels (title, description, primaryActionLabel) come from i18n.
+     */
+    emptyState?: ResourceUIBehavior_EmptyState;
+    /**
+     * Resource-level guidance flow declarations.
+     * Compiled into standard `GuidanceFlowDefinition` objects by the guidance compiler.
+     */
+    guidance?: ResourceUIBehavior_GuidanceFlow[];
+    /**
+     * Per-relationship display overrides for this resource.
+     *
+     * Allows the frontend preset to override how relationships are displayed
+     * without modifying the shared `display` config on the relationship itself.
+     * Consumed at build time by `resolveRelationshipDisplayOverrides()` and
+     * stripped from `frontendConfiguration` before storage.
+     *
+     * @see RelationshipDisplayOverride
+     */
+    relationshipOverrides?: RelationshipDisplayOverride[];
+    /**
+     * Per-operation frontend configuration — which operations have a UI view
+     * and how they appear (addressability, launchers, overrides).
+     *
+     * Keyed by `TypedOperationKey`:
+     * - `string` — default operation (e.g., `CoreResourceOperation.READ`)
+     * - `[operationId, variantKey]` — non-default variant
+     *
+     * When typed via `resourceUIBehavior()`, operation keys are validated
+     * at compile time against the resource's valid operations.
+     */
+    views: Map<TypedOperationKey<TCustomOp, TCoreOp>, ResourceOperationFrontendConfig>;
+};
+/**
+ * Resource-level UI behavior configuration — the subset of `ResourceUIBehaviorConfig`
+ * that describes the resource itself (labels, sections, views, empty state, guidance),
+ * excluding `views` (lives on individual operation entries),
+ * `relationshipOverrides` (consumed at build time, not stored at runtime).
+ *
+ * Resource-owned composite/execution authoring maps are compiled into inserted
+ * runtime declarations before storage.
+ *
+ * This is what gets written to `FrontendResourceConfiguration.frontendConfiguration`
+ * during preset-driven registry build.
+ */
+export type ResourceUIBehaviorResourceLevelConfig<TCustomOp extends EnumLikeType | undefined = any, TCoreOp extends Partial<CoreResourceOperation> | undefined = any, TMainSchema extends z.ZodTypeAny = z.ZodAny> = Omit<ResourceUIBehaviorConfig<TCustomOp, TCoreOp, TMainSchema>, 'views' | 'relationshipOverrides' | 'compositeViews' | 'executionViews'> & {
+    compositeViews?: InsertedCompositeDeclaration[];
+    executionViews?: InsertedExecutionDeclaration[];
+};
+/**
+ * Complete frontend resource configuration preset for an application.
+ *
+ * Maps resource types to their full frontend configuration — including
+ * resource-level settings (labels, sections, views, empty state, guidance)
+ * and operation-level settings (addressability, launchers, overrides).
+ *
+ * Each application provides its own preset defining exactly which resources
+ * and operations it exposes and how they appear in the UI.
+ *
+ * When authoring presets, use `resourceUIBehavior()` which accepts views
+ * as an array of tuples (for contextual typing) and converts to Map internally.
+ *
+ * @example
+ * ```
+ * const preset: ResourceUIBehavior = {
+ *   [CoreResourceType.ORGANIZATIONS]: resourceUIBehavior(factory, Schema, ({ schema, schemaShape, opsVariantResolver }) => ({
+ *     getFrontendResourceLabel: ({ currentObject }) => currentObject.name,
+ *     views: [
+ *       [CoreResourceOperation.CREATE, { isAddressable: false }],
+ *       [CoreResourceOperation.READ, { isAddressable: false }],
+ *     ],
+ *   })),
+ * };
+ * ```
+ */
+export type ResourceUIBehavior = Record<string, ResourceUIBehaviorConfig>;
+/**
+ * A single variant within a polymorphic frontend declaration.
+ * Maps a parent resource type (the discriminator) to the concrete resource type it produces.
+ *
+ * Mirrors the backend's `PolymorphicResolvedVariant` — stripped of schema-level
+ * concerns, keeping only the routing information the frontend needs.
+ */
+export interface PolymorphicFrontendVariant {
+    /** Parent resource type — the polymorphic discriminator (e.g., `CoreResourceType.ORGANIZATIONS`) */
+    parentResourceType: string;
+    /** Concrete resource type for this variant (e.g., `CoreResourceType.ORGANIZATION_BILLING_ACCOUNTS`) */
+    resourceType: string;
+}
+/**
+ * Frontend polymorphic declaration — lightweight equivalent of the backend's
+ * `PolymorphicSchemaDeclaration`.
+ *
+ * Contains the variant mapping (discriminator → concrete resource type) without
+ * any Zod schema coupling. Used by `createPolymorphicFrontendPreset()` to generate
+ * per-variant preset entries.
+ *
+ * Declarations are typically defined per resource family (billing accounts,
+ * subscriptions, SSO config, etc.) and mirror the backend's
+ * `BILLING_SCOPE_VARIANTS` / `AUTH_SCOPE_VARIANTS` grouping.
+ *
+ * @example
+ * ```ts
+ * const BILLING_ACCOUNTS: PolymorphicFrontendDeclaration = {
+ *   variants: [
+ *     { parentResourceType: CoreResourceType.ORGANIZATIONS, resourceType: CoreResourceType.ORGANIZATION_BILLING_ACCOUNTS },
+ *     { parentResourceType: CoreResourceType.USERS, resourceType: CoreResourceType.USER_BILLING_ACCOUNTS },
+ *   ],
+ * };
+ * ```
+ */
+export interface PolymorphicFrontendDeclaration {
+    variants: PolymorphicFrontendVariant[];
+}
+/**
+ * Resource frontend config with optional per-variant overrides.
+ *
+ * Mirrors the backend's `PolymorphicResourceConfig` + `polymorphicRole` pattern:
+ * - Shared fields apply to all scope variants as the default
+ * - `variantOverrides` keyed by `parentResourceType` (the discriminator)
+ *   allow per-variant differentiation — just like `polymorphicRole` resolves
+ *   different roles per parent resource type
+ *
+ * Override resolution (same as backend `polymorphicRole`):
+ * - If a variant's `parentResourceType` is in `variantOverrides`, the override
+ *   **replaces** the corresponding shared fields (not merged)
+ * - If not present, the shared config is used as-is (fallback)
+ * - `views` in an override fully replaces the shared views Map
+ *   (use an empty `new Map()` to make a variant invisible in the preset)
+ */
+export type PolymorphicResourceUIBehaviorConfig<TCustomOp extends EnumLikeType | undefined = any, TCoreOp extends Partial<CoreResourceOperation> | undefined = any, TMainSchema extends z.ZodTypeAny = z.ZodAny> = Omit<ResourceUIBehaviorConfig<TCustomOp, TCoreOp, TMainSchema>, 'views'> & {
+    /**
+     * Per-operation frontend config — array-of-tuples form (converted to Map internally).
+     * Same semantics as `ResourceUIBehaviorConfig.views` but using arrays for
+     * TypeScript contextual typing compatibility.
+     */
+    views: OperationEntries<TCustomOp, TCoreOp>;
+    /**
+     * Per-variant overrides, keyed by `parentResourceType` (the polymorphic discriminator).
+     *
+     * Like backend `polymorphicRole`, provides variant-specific configuration.
+     * Each override **replaces** the corresponding shared field — `views`
+     * is a full replacement, not a merge. If `views` is omitted in the
+     * override, the shared views apply.
+     *
+     * Pass an empty array `[]` for `views` to exclude a variant from
+     * surfacing in the preset (variant still exists in the declaration, but
+     * has no frontend operations).
+     */
+    variantOverrides?: Record<string, Partial<Omit<ResourceUIBehaviorConfig<TCustomOp, TCoreOp, TMainSchema>, 'views'>> & {
+        views?: OperationEntries<TCustomOp, TCoreOp>;
+    }>;
+};
+/**
+ * Return type of the `polymorphicResourceUIBehavior()` callback overload.
+ * Same structure as `PolymorphicResourceUIBehaviorConfig` — the callback form
+ * provides `{ schema, schemaShape, opsVariantResolver }` for the same typed control as `resourceUIBehavior()`:
+ * operation keys in `views` and `variantOverrides` are validated at compile time.
+ */
+export type PolymorphicResourceUIBehaviorConfigResult<TCustomOp extends EnumLikeType | undefined = any, TCoreOp extends Partial<CoreResourceOperation> | undefined = any, TMainSchema extends z.ZodTypeAny = z.ZodAny> = PolymorphicResourceUIBehaviorConfig<TCustomOp, TCoreOp, TMainSchema>;
+/**
+ * Creates frontend preset entries for all scope variants of a polymorphic resource.
+ *
+ * Mirrors the backend `createPolymorphicResourceConfigurations` pattern:
+ * takes a polymorphic declaration (discriminator → concrete resource types) and
+ * a shared config with optional per-variant overrides, producing a
+ * `ResourceUIBehavior` partial that can be spread into the main preset.
+ *
+ * Resolution per variant (same semantics as backend `polymorphicRole` → `roles`):
+ * 1. If `variantOverrides[parentResourceType]` exists → override fields **replace**
+ *    corresponding shared fields (views is a full replacement, not merge)
+ * 2. If no override → shared config used as-is (fallback)
+ *
+ * The declaration must always contain ALL variants of the polymorphic resource.
+ * Use `variantOverrides` with an empty `views: []` to exclude a variant
+ * from a specific preset (the variant is declared but has no frontend presence).
+ *
+ * @param declaration - Polymorphic frontend declaration with ALL variant mappings
+ * @param config - Shared config (default) with optional `variantOverrides` per discriminator
+ * @returns Partial `ResourceUIBehavior` with one entry per variant
+ *
+ * @example
+ * ```ts
+ * // Main app: org scope gets full ops, app scope excluded
+ * ...createPolymorphicFrontendPreset({
+ *   variants: [
+ *     { parentResourceType: R.ORGANIZATIONS, resourceType: R.ORGANIZATION_SSO_CONFIG },
+ *     { parentResourceType: R.APPLICATION, resourceType: R.APPLICATION_SSO_CONFIG },
+ *   ],
+ * }, {
+ *   views: [
+ *     [Op.READ, addressable()],
+ *     [SsoConfig_Operations.ADD_DOMAIN, notAddressable()],
+ *   ],
+ *   variantOverrides: {
+ *     [R.APPLICATION]: { views: [] },
+ *   },
+ * }),
+ *
+ * // Admin app: app scope gets full ops, org scope read-only
+ * ...createPolymorphicFrontendPreset({
+ *   variants: [
+ *     { parentResourceType: R.ORGANIZATIONS, resourceType: R.ORGANIZATION_SSO_CONFIG },
+ *     { parentResourceType: R.APPLICATION, resourceType: R.APPLICATION_SSO_CONFIG },
+ *   ],
+ * }, {
+ *   views: [
+ *     [Op.READ, addressable()],
+ *     [SsoConfig_Operations.ADD_DOMAIN, notAddressable()],
+ *   ],
+ *   variantOverrides: {
+ *     [R.ORGANIZATIONS]: {
+ *       views: [
+ *         [Op.READ, notAddressable()],
+ *         [Op.LIST, notAddressable()],
+ *       ],
+ *     },
+ *   },
+ * }),
+ * ```
+ */
+export declare function createPolymorphicFrontendPreset(declaration: PolymorphicFrontendDeclaration, config: PolymorphicResourceUIBehaviorConfig): ResourceUIBehavior;
+/** Extracts the custom operation enum from a `ResourceConfiguration` or its factory. */
+export type ExtractCustomOp<T> = T extends ResourceConfiguration<infer C, any, any> ? C : T extends ResourceConfiguration_InitializationFactory<infer C, any, any> ? C : never;
+/** Extracts the core operation enum from a `ResourceConfiguration` or its factory. */
+export type ExtractCoreOp<T> = T extends ResourceConfiguration<any, infer O, any> ? O : T extends ResourceConfiguration_InitializationFactory<any, infer O, any> ? O : never;
+/** Extracts the main Zod schema from a `ResourceConfiguration` or its factory. */
+export type ExtractSchema<T> = T extends ResourceConfiguration<any, any, infer S> ? S : T extends ResourceConfiguration_InitializationFactory<any, any, infer S> ? S : never;
+/**
+ * Creates a typed operation variant tuple `[operationKey, variantKey]`.
+ * Preserves the literal operation key for `TypedOperationKey` assignability.
+ */
+export declare function variant<TOp extends string>(op: TOp, variantKey: string): readonly [TOp, string];
+/**
+ * Array-of-tuples form for specifying operations in input contexts
+ * (`resourceUIBehavior` callback, `polymorphicResourceUIBehavior` config).
+ *
+ * TypeScript's `new Map([...])` doesn't pick up contextual typing for
+ * heterogeneous key types, so input types use arrays — the factory functions
+ * convert to `Map` at the boundary. Each entry's key is individually checked
+ * against `TypedOperationKey<TCustomOp, TCoreOp>` via contextual typing.
+ */
+export type OperationEntries<TCustomOp extends EnumLikeType | undefined = any, TCoreOp extends Partial<CoreResourceOperation> | undefined = any> = [TypedOperationKey<TCustomOp, TCoreOp>, ResourceOperationFrontendConfig][];
+/**
+ * Single object parameter passed to the `resourceUIBehavior()` and
+ * `polymorphicResourceUIBehavior()` callback.
+ */
+export type ResourceUIBehaviorCallbackParams<TCustomOp extends EnumLikeType | undefined, TCoreOp extends Partial<CoreResourceOperation> | undefined, TSchema extends z.ZodTypeAny> = {
+    schema: TSchema;
+    schemaShape: ObjectShape<TSchema>;
+    opsVariantResolver: <TOp extends ValidOperationKeys<TCustomOp, TCoreOp>>(op: TOp, variantKey: string) => readonly [TOp, string];
+};
+/**
+ * Return type of the `resourceUIBehavior()` callback — overrides `views`
+ * to accept an array of tuples (instead of Map) for ergonomic authoring.
+ * The `resourceUIBehavior()` function converts the array to a Map.
+ *
+ * `schemaOverride` is applied during callback execution as a side effect and
+ * stripped from the returned config. Must appear BEFORE `fields` in the
+ * object literal to ensure schema-level defaults are set before field-level overrides.
+ */
+export type ResourceUIBehaviorConfigResult<TCustomOp extends EnumLikeType | undefined, TCoreOp extends Partial<CoreResourceOperation> | undefined, TSchema extends z.ZodTypeAny> = Omit<ResourceUIBehaviorConfig<TCustomOp, TCoreOp, TSchema>, 'views'> & {
+    views: OperationEntries<TCustomOp, TCoreOp>;
+    schemaOverride?: TSchema;
+};
+/**
+ * Creates a typed `ResourceUIBehaviorConfig` entry for a given resource.
+ *
+ * All generics are inferred from the `_factory` argument — no explicit type
+ * parameters needed. The callback receives `{ schema, schemaShape, opsVariantResolver }`:
+ * - `schema` — the Zod schema (for schema-level mutations like `.stringUI()`, `.enumUI()`, etc.)
+ * - `schemaShape` — the typed shape object (for per-field decorator overrides with autocomplete)
+ * - `opsVariantResolver` — typed variant tuple helper constrained to valid operation keys
+ *
+ * The `_factory` parameter is for **type inference only** and is never called at runtime.
+ *
+ * @example
+ * ```ts
+ * [R.TODOS]: resourceUIBehavior(
+ *   todos_ResourceConfiguration_InitializationFactory,
+ *   Todos_Schema,
+ *   ({ schema, schemaShape, opsVariantResolver }) => ({
+ *     icon: CheckSquare,
+ *     fields: {
+ *       status: schemaShape.status.enumUI({
+ *         values: { completed: { color: 'success', icon: CheckCircle } },
+ *       }),
+ *     },
+ *     views: [
+ *       [CoreResourceOperation.LIST, { isAddressable: true }],
+ *       [opsVariantResolver(CoreResourceOperation.CREATE, 'quick-add'), { isAddressable: false }],
+ *     ],
+ *   }),
+ * ),
+ * ```
+ */
+export declare function resourceUIBehavior<TCustomOp extends EnumLikeType | undefined, TCoreOp extends Partial<CoreResourceOperation> | undefined, TSchema extends z.ZodTypeAny>(_factory: ResourceConfigLike<TCustomOp, TCoreOp, TSchema>, schema: TSchema, configFactory: (params: ResourceUIBehaviorCallbackParams<TCustomOp, TCoreOp, TSchema>) => ResourceUIBehaviorConfigResult<TCustomOp, TCoreOp, TSchema>): ResourceUIBehaviorConfig;
+/**
+ * Callback parameter type for `resourceUIBehaviorFrom()`.
+ * Extends the standard callback params with a `base` reference to the resolved base config.
+ */
+export type ResourceUIBehaviorFromCallbackParams<TCustomOp extends EnumLikeType | undefined, TCoreOp extends Partial<CoreResourceOperation> | undefined, TSchema extends z.ZodTypeAny> = ResourceUIBehaviorCallbackParams<TCustomOp, TCoreOp, TSchema> & {
+    /** The resolved base config — use to reference existing values when composing overrides. */
+    base: ResourceUIBehaviorConfig<TCustomOp, TCoreOp, TSchema>;
+};
+/**
+ * Return type of the `resourceUIBehaviorFrom()` callback — everything is optional.
+ *
+ * Merge semantics applied by `resourceUIBehaviorFrom`:
+ * - `views` — **replaced** (the primary differentiator between main/admin)
+ * - `layout` — **shallow-merged** (`{ ...base.layout, ...override.layout }`)
+ * - `fields` — **shallow-merged** (base fields preserved, overrides overlay per-key)
+ * - `compositeViews` — **shallow-merged** by ref (`{ ...base.compositeViews, ...override.compositeViews }`)
+ * - `executionViews` — **shallow-merged** by ref (`{ ...base.executionViews, ...override.executionViews }`)
+ * - Scalars (`icon`, `emptyState`, `getFrontendResourceLabel`, etc.) — **replaced** if provided
+ */
+export type ResourceUIBehaviorFromResult<TCustomOp extends EnumLikeType | undefined, TCoreOp extends Partial<CoreResourceOperation> | undefined, TSchema extends z.ZodTypeAny> = Partial<Omit<ResourceUIBehaviorConfig<TCustomOp, TCoreOp, TSchema>, 'views'>> & {
+    views?: OperationEntries<TCustomOp, TCoreOp>;
+};
+/**
+ * Derives a new `ResourceUIBehaviorConfig` from an existing base, overriding only
+ * the specified properties. Eliminates duplication between main and admin presets
+ * where the majority of the config (icon, fields, layout, labels) is identical
+ * and only `views` (and occasionally `variantOverrides`) differ.
+ *
+ * The `_factory` parameter is for **type inference only** — same as `resourceUIBehavior()`.
+ * The schema is extracted from the base config via `FRONTEND_SCHEMA_KEY`, so it does not
+ * need to be passed again.
+ *
+ * For resources that are completely identical between main and admin, skip this function
+ * entirely and forward the config directly: `[R.PRODUCTS]: main[R.PRODUCTS]!`
+ *
+ * @param _factory - Any factory from the resource — for type inference only (never called)
+ * @param base - The resolved base `ResourceUIBehaviorConfig` (from main presets)
+ * @param overrideFn - Callback returning only the properties to override
+ *
+ * @example
+ * ```ts
+ * // Admin promotions — same icon/fields/layout, different views
+ * [R.PROMOTIONS]: resourceUIBehaviorFrom(
+ *   promotionsFactory,
+ *   main[R.PROMOTIONS]!,
+ *   ({ opsVariantResolver }) => ({
+ *     views: [
+ *       [Promotion_Operations.DEACTIVATE, notAddressable()],
+ *     ],
+ *   })
+ * ),
+ * ```
+ */
+export declare function resourceUIBehaviorFrom<TCustomOp extends EnumLikeType | undefined, TCoreOp extends Partial<CoreResourceOperation> | undefined, TSchema extends z.ZodTypeAny>(_factory: ResourceConfigLike<TCustomOp, TCoreOp, TSchema>, base: ResourceUIBehaviorConfig, overrideFn: (params: ResourceUIBehaviorFromCallbackParams<TCustomOp, TCoreOp, TSchema>) => ResourceUIBehaviorFromResult<TCustomOp, TCoreOp, TSchema>): ResourceUIBehaviorConfig;
+/**
+ * Return type of the `polymorphicResourceUIBehaviorFrom()` callback — everything is optional.
+ * Same merge semantics as `resourceUIBehaviorFrom()`, plus `variantOverrides` is shallow-merged
+ * per parent key (inner overrides replace, not merge).
+ */
+export type PolymorphicResourceUIBehaviorFromResult<TCustomOp extends EnumLikeType | undefined, TCoreOp extends Partial<CoreResourceOperation> | undefined, TSchema extends z.ZodTypeAny> = Partial<Omit<PolymorphicResourceUIBehaviorConfig<TCustomOp, TCoreOp, TSchema>, 'views'>> & {
+    views?: OperationEntries<TCustomOp, TCoreOp>;
+};
+/**
+ * Derives a polymorphic preset from an existing base, overriding only the specified
+ * properties. Works like `resourceUIBehaviorFrom()` but for polymorphic resources
+ * produced by `polymorphicResourceUIBehavior()`.
+ *
+ * The base entries are the already-spread `Partial<ResourceUIBehavior>` from the main
+ * preset. Internally, the first variant's config is used as the shared base — the
+ * callback receives it as `base` and returns only what changes.
+ *
+ * @param declaration - Same polymorphic declaration used in the main preset
+ * @param _factory - Any single factory from the polymorphic map — for type inference only
+ * @param baseEntries - The spread result from the main preset (keyed by concrete resource type)
+ * @param overrideFn - Callback returning only the properties to override
+ *
+ * @example
+ * ```ts
+ * // Admin SIEM — same icon/layout/fields, different variantOverrides
+ * ...polymorphicResourceUIBehaviorFrom(
+ *   SIEM_EXPORT_DECLARATION,
+ *   siemFactory,
+ *   main,
+ *   ({ opsVariantResolver }) => ({
+ *     variantOverrides: {
+ *       [R.ORGANIZATIONS]: {
+ *         views: [[Op.READ, notAddressable()]],
+ *       },
+ *     },
+ *   })
+ * ),
+ * ```
+ */
+export declare function polymorphicResourceUIBehaviorFrom<TCustomOp extends EnumLikeType | undefined, TCoreOp extends Partial<CoreResourceOperation> | undefined, TSchema extends z.ZodTypeAny>(declaration: PolymorphicFrontendDeclaration, _factory: ResourceConfigLike<TCustomOp, TCoreOp, TSchema>, baseEntries: Partial<ResourceUIBehavior>, overrideFn: (params: ResourceUIBehaviorFromCallbackParams<TCustomOp, TCoreOp, TSchema>) => PolymorphicResourceUIBehaviorFromResult<TCustomOp, TCoreOp, TSchema>): ResourceUIBehavior;
+/**
+ * Creates a typed polymorphic UI behavior preset — wraps `createPolymorphicFrontendPreset()`
+ * with type inference from a factory or configuration.
+ *
+ * For resources built with `createFamilySchema` (discriminated unions), the factory
+ * provides the generic context for `fields` typing and operation key validation.
+ *
+ * **Two overloads** — use the callback form for the same typed control as `resourceUIBehavior()`:
+ * - Callback: `(declaration, factory, schema, ({ schema, schemaShape, opsVariantResolver }) => config)` — operation keys
+ *   in `views` and `variantOverrides` are validated at compile time via the `opsVariantResolver` helper.
+ * - Object: `(declaration, factory, config)` — config object; typing may be weaker for array literals.
+ *
+ * @param declaration - Polymorphic frontend declaration with variant mappings
+ * @param _factory - Any single factory from the polymorphic map — for type inference only
+ * @param schemaOrConfig - Base schema (for callback form) or config object (for object form)
+ * @param configFactory - Callback form only: receives { schema, schemaShape, opsVariantResolver } like resourceUIBehavior
+ */
+export declare function polymorphicResourceUIBehavior<TCustomOp extends EnumLikeType | undefined, TCoreOp extends Partial<CoreResourceOperation> | undefined, TSchema extends z.ZodTypeAny>(declaration: PolymorphicFrontendDeclaration, _factory: ResourceConfigLike<TCustomOp, TCoreOp, TSchema>, schema: TSchema, configFactory: (params: ResourceUIBehaviorCallbackParams<TCustomOp, TCoreOp, TSchema>) => PolymorphicResourceUIBehaviorConfigResult<TCustomOp, TCoreOp, TSchema>): ResourceUIBehavior;
+export declare function polymorphicResourceUIBehavior<TCustomOp extends EnumLikeType | undefined, TCoreOp extends Partial<CoreResourceOperation> | undefined, TSchema extends z.ZodTypeAny>(declaration: PolymorphicFrontendDeclaration, _factory: ResourceConfigLike<TCustomOp, TCoreOp, TSchema>, config: PolymorphicResourceUIBehaviorConfig<TCustomOp, TCoreOp, TSchema>): ResourceUIBehavior;
+export {};
+//# sourceMappingURL=resources.frontend.schemas.d.ts.map