@btst/plugin-cms 0.0.0-stage → 1.0.0-beta.0

package/dist/client/index.d.ts

@@ -0,0 +1,654 @@
+'use client';
+import * as _btst_stack_client from '@btst/stack/client';
+import * as _btst_yar from '@btst/yar';
+import * as react from 'react';
+import { ComponentType } from 'react';
+import { D as DashboardPageComponent } from '../shared/plugin-cms.BBshPRkb.js';
+import { ContentTypeConfig } from '../types.js';
+export { CMSContentFields, CMSContentItemResult, CMSReadOptions, CMSReadView, CMSSelectedData, PaginatedContentItems, SerializedContentItemContent } from '../types.js';
+import { ControllerRenderProps, FieldValues } from 'react-hook-form';
+import * as z from 'zod';
+import { z as z$1 } from 'zod';
+
+declare const CMS_LOCALIZATION: {
+    CMS_RELATION_LOADING: string;
+    CMS_RELATION_SELECT_PLACEHOLDER: string;
+    CMS_RELATION_SELECT_PLACEHOLDER_MULTI: string;
+    CMS_RELATION_EMPTY: string;
+    CMS_RELATION_CREATE_TITLE: string;
+    CMS_RELATION_NAME_PLACEHOLDER: string;
+    CMS_RELATION_DESCRIPTION_LABEL: string;
+    CMS_RELATION_DESCRIPTION_PLACEHOLDER: string;
+    CMS_RELATION_CREATE_BUTTON: string;
+    CMS_RELATION_CREATING: string;
+    CMS_RELATION_CREATE_ERROR: string;
+    CMS_RELATED_ITEMS_TITLE: string;
+    CMS_RELATED_EMPTY: string;
+    CMS_RELATED_ADD: string;
+    CMS_RELATED_DELETE_TITLE: string;
+    CMS_RELATED_DELETE_DESCRIPTION: string;
+    CMS_RELATED_DELETE_ERROR: string;
+    CMS_EDITOR_TITLE_NEW: string;
+    CMS_EDITOR_TITLE_EDIT: string;
+    CMS_EDITOR_SLUG_AUTO: string;
+    CMS_EDITOR_SLUG_MANUAL: string;
+    CMS_EDITOR_DELETE_CONFIRM: string;
+    CMS_EDITOR_UNSAVED_CHANGES: string;
+    CMS_EDITOR_SLUG_PLACEHOLDER: string;
+    CMS_EDITOR_SLUG_PLACEHOLDER_AUTO: string;
+    CMS_EDITOR_SLUG_REQUIRED: string;
+    CMS_EDITOR_FILE_INVALID_TYPE: string;
+    CMS_EDITOR_FILE_UPLOAD_FAILED: string;
+    CMS_LIST_TITLE: string;
+    CMS_LIST_EMPTY: string;
+    CMS_LIST_EMPTY_DESCRIPTION: string;
+    CMS_LIST_COLUMN_SLUG: string;
+    CMS_LIST_COLUMN_CREATED: string;
+    CMS_LIST_COLUMN_UPDATED: string;
+    CMS_LIST_COLUMN_ACTIONS: string;
+    CMS_LIST_ACTION_EDIT: string;
+    CMS_LIST_ACTION_DELETE: string;
+    CMS_LIST_PAGINATION_SHOWING: string;
+    CMS_LIST_PAGINATION_PREVIOUS: string;
+    CMS_LIST_PAGINATION_NEXT: string;
+    CMS_LIST_SEARCH_PLACEHOLDER: string;
+    CMS_LIST_SEARCH_EMPTY: string;
+    CMS_LIST_SEARCH_EMPTY_DESCRIPTION: string;
+    CMS_DASHBOARD_TITLE: string;
+    CMS_DASHBOARD_SUBTITLE: string;
+    CMS_DASHBOARD_NO_TYPES: string;
+    CMS_DASHBOARD_NO_TYPES_DESCRIPTION: string;
+    CMS_DASHBOARD_ITEMS_COUNT: string;
+    CMS_DASHBOARD_ITEMS_COUNT_ZERO: string;
+    CMS_DASHBOARD_ITEMS_COUNT_ONE: string;
+    CMS_TOAST_CREATE_SUCCESS: string;
+    CMS_TOAST_UPDATE_SUCCESS: string;
+    CMS_TOAST_DELETE_SUCCESS: string;
+    CMS_TOAST_ERROR: string;
+    CMS_TOAST_VALIDATION_ERROR: string;
+    CMS_TOAST_DUPLICATE_SLUG: string;
+    CMS_BUTTON_SAVE: string;
+    CMS_BUTTON_CANCEL: string;
+    CMS_BUTTON_DELETE: string;
+    CMS_BUTTON_CREATE: string;
+    CMS_BUTTON_BACK: string;
+    CMS_BUTTON_NEW_ITEM: string;
+    CMS_LABEL_SLUG: string;
+    CMS_LABEL_SLUG_DESCRIPTION: string;
+    CMS_LABEL_CREATED_AT: string;
+    CMS_LABEL_UPDATED_AT: string;
+    CMS_LABEL_ACTIONS: string;
+    CMS_STATUS_LOADING: string;
+    CMS_STATUS_SAVING: string;
+    CMS_STATUS_DELETING: string;
+    CMS_ERROR_GENERIC: string;
+    CMS_ERROR_NOT_FOUND: string;
+    CMS_ERROR_VALIDATION: string;
+    CMS_ERROR_TYPE_NOT_FOUND_DESCRIPTION: string;
+    CMS_ERROR_ITEM_NOT_FOUND_DESCRIPTION: string;
+    CMS_404_TITLE: string;
+    CMS_404_DESCRIPTION: string;
+    CMS_404_BACK: string;
+    CMS_ATTRIBUTION: string;
+};
+type CMSLocalization = typeof CMS_LOCALIZATION;
+
+declare function AutoFormCheckbox({ label, isRequired, field, fieldConfigItem, fieldProps, }: AutoFormInputComponentProps): react.JSX.Element;
+
+declare function AutoFormDate({ label, isRequired, field, fieldConfigItem, fieldProps, zodItem, }: AutoFormInputComponentProps): react.JSX.Element;
+
+declare function AutoFormEnum({ label, isRequired, field, fieldConfigItem, zodItem, fieldProps, }: AutoFormInputComponentProps): react.JSX.Element;
+
+declare function AutoFormInput({ label, isRequired, fieldConfigItem, fieldProps, }: AutoFormInputComponentProps): react.JSX.Element;
+
+declare function AutoFormNumber({ label, isRequired, fieldConfigItem, fieldProps, }: AutoFormInputComponentProps): react.JSX.Element;
+
+declare function AutoFormRadioGroup({ label, isRequired, field, zodItem, fieldProps, fieldConfigItem, }: AutoFormInputComponentProps): react.JSX.Element;
+
+declare function AutoFormSwitch({ label, isRequired, field, fieldConfigItem, fieldProps, }: AutoFormInputComponentProps): react.JSX.Element;
+
+declare function AutoFormTextarea({ label, isRequired, fieldConfigItem, fieldProps, }: AutoFormInputComponentProps): react.JSX.Element;
+
+declare const INPUT_COMPONENTS: {
+    checkbox: typeof AutoFormCheckbox;
+    date: typeof AutoFormDate;
+    select: typeof AutoFormEnum;
+    radio: typeof AutoFormRadioGroup;
+    switch: typeof AutoFormSwitch;
+    textarea: typeof AutoFormTextarea;
+    number: typeof AutoFormNumber;
+    fallback: typeof AutoFormInput;
+};
+
+/**
+ * Common input props shared by all field types.
+ */
+interface BaseInputProps {
+    /** Whether the field is disabled */
+    disabled?: boolean;
+    /** Whether the field is read-only */
+    readOnly?: boolean;
+    /** Whether the field is required */
+    required?: boolean;
+    /** Whether to show the label (auto-form specific) */
+    showLabel?: boolean;
+}
+/**
+ * Generic input props that accept any field type.
+ * Use this when the backing type is not known at compile time.
+ *
+ * This is the catch-all type used for runtime flexibility.
+ */
+interface SerializableInputProps extends BaseInputProps {
+    placeholder?: string;
+    type?: string;
+    defaultValue?: unknown;
+    min?: number | string;
+    max?: number | string;
+    step?: number | string;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    autoComplete?: string;
+    /** Allow additional props for extensibility */
+    [key: string]: unknown;
+}
+
+/**
+ * Input props for form fields.
+ *
+ * This is the runtime type that accepts any input props.
+ * For type-safe props, use the discriminated types:
+ * - StringInputProps for text inputs
+ * - NumberInputProps for number inputs
+ * - BooleanInputProps for checkboxes/switches
+ * - DateInputProps for date pickers
+ * - EnumInputProps for selects/radios
+ */
+type FieldInputProps = SerializableInputProps & Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof SerializableInputProps> & Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, keyof SerializableInputProps>;
+/**
+ * Configuration for a single field in AutoForm.
+ *
+ * Note: This type is designed to align with form-builder's FormBuilderFieldProps
+ * so that JSON Schema properties can be easily converted to field configs.
+ */
+type FieldConfigItem = {
+    /** Description text or React node */
+    description?: React.ReactNode;
+    /** Input props passed to the field component */
+    inputProps?: FieldInputProps;
+    /** Display label */
+    label?: string;
+    /** Field type override - built-in type or custom component */
+    fieldType?: keyof typeof INPUT_COMPONENTS | React.FC<AutoFormInputComponentProps>;
+    /** Wrapper component for custom field layout */
+    renderParent?: (props: {
+        children: React.ReactNode;
+    }) => React.ReactElement | null;
+    /** Display order for field ordering */
+    order?: number;
+};
+/**
+ * A FormInput component can handle a specific Zod type (e.g. "ZodBoolean")
+ */
+type AutoFormInputComponentProps = {
+    zodInputProps: React.InputHTMLAttributes<HTMLInputElement>;
+    field: ControllerRenderProps<FieldValues, any>;
+    fieldConfigItem: FieldConfigItem;
+    label: string;
+    isRequired: boolean;
+    fieldProps: any;
+    zodItem: z.ZodType;
+    className?: string;
+};
+
+/** Browser-safe CMS factory values carried by the resolved client stack. */
+interface CMSProviderConfig {
+    /** Declared content types, used to preserve application-defined UI order. */
+    readonly contentTypes?: readonly ContentTypeConfig[];
+}
+/**
+ * Props for the overridable CMS image input field component.
+ */
+interface CmsImageInputFieldProps {
+    /** Current image URL value */
+    value: string;
+    /** Called when the image URL changes */
+    onChange: (value: string) => void;
+    /** Whether the field is required */
+    isRequired?: boolean;
+}
+/**
+ * Context passed to lifecycle hooks
+ */
+interface RouteContext {
+    /** Current route path */
+    path: string;
+    /** Route parameters (e.g., { typeSlug: "product", id: "123" }) */
+    params?: Record<string, string>;
+    /** Whether rendering on server (true) or client (false) */
+    isSSR: boolean;
+    /** Additional context properties */
+    [key: string]: unknown;
+}
+/**
+ * Overridable components and functions for the CMS plugin
+ *
+ * External consumers can provide their own implementations to customize
+ * plugin-specific components and behavior.
+ */
+interface CMSPluginOverrides {
+    /**
+     * Function used to upload a new image file and return its URL.
+     * Used by the default "file" field component when not selecting an existing
+     * asset via `imagePicker` or `imageInputField`.
+     */
+    uploadImage?: (file: File) => Promise<string>;
+    /**
+     * Optional custom component for image fields (fieldType: "file").
+     *
+     * When provided it replaces the default file-upload input entirely.
+     * The component receives `value` (current URL string) and `onChange` (setter).
+     *
+     * @example
+     * ```tsx
+     * imageInputField: ({ value, onChange }) =>
+     *   value ? (
+     *     <div>
+     *       <img src={value} alt="Preview" />
+     *       <MediaPicker trigger={<button>Change</button>} accept={["image/*"]}
+     *         onSelect={(assets) => onChange(assets[0].url)} />
+     *     </div>
+     *   ) : (
+     *     <MediaPicker trigger={<button>Browse media</button>} accept={["image/*"]}
+     *       onSelect={(assets) => onChange(assets[0].url)} />
+     *   )
+     * ```
+     */
+    imageInputField?: ComponentType<CmsImageInputFieldProps>;
+    /**
+     * Optional trigger component for a media picker.
+     * When provided, it is rendered inside the default "file" field component as a
+     * "Browse media" option, letting users select a previously uploaded asset.
+     * Receives `onSelect(url)` — the URL is set as the field value.
+     *
+     * @example
+     * ```tsx
+     * imagePicker: ({ onSelect }) => (
+     *   <MediaPicker
+     *     trigger={<Button size="sm" variant="outline">Browse media</Button>}
+     *     accept={["image/*"]}
+     *     onSelect={(assets) => onSelect(assets[0].url)}
+     *   />
+     * )
+     * ```
+     */
+    imagePicker?: ComponentType<{
+        onSelect: (url: string) => void;
+    }>;
+    /**
+     * Optional class names merged onto specific UI elements.
+     * Use these for targeted styling without replacing whole components.
+     */
+    classNames?: {
+        /** Page container shared by every CMS page */
+        container?: string;
+        /** Each content-type card on the dashboard */
+        contentTypeCard?: string;
+        /** Title inside a content-type card */
+        contentTypeTitle?: string;
+        /** Wrapper around the content entries table */
+        table?: string;
+        /** Each row in the content entries table */
+        tableRow?: string;
+        /** Pagination footer under the content entries table */
+        pagination?: string;
+    };
+    /**
+     * Custom field components for AutoForm fields.
+     *
+     * These map field type names to React components. Use these to:
+     * - Override built-in field types (checkbox, date, select, radio, switch, textarea, file, number, fallback)
+     * - Add custom field types for your content types
+     *
+     * The component receives AutoFormInputComponentProps which includes:
+     * - field: react-hook-form field controller
+     * - label: the field label
+     * - isRequired: whether the field is required
+     * - fieldConfigItem: the field config (description, inputProps, etc.)
+     * - fieldProps: additional props from fieldConfig.inputProps
+     * - zodItem: the Zod schema for this field
+     *
+     * @example
+     * ```tsx
+     * fieldComponents: {
+     *   // Override the file type with custom S3 upload
+     *   file: ({ field, label, isRequired }) => (
+     *     <MyS3Upload
+     *       value={field.value}
+     *       onChange={field.onChange}
+     *       label={label}
+     *       required={isRequired}
+     *     />
+     *   ),
+     *   // Add a custom rich text editor
+     *   richText: ({ field, label }) => (
+     *     <MyRichTextEditor value={field.value} onChange={field.onChange} />
+     *   ),
+     * }
+     * ```
+     */
+    fieldComponents?: Record<string, ComponentType<AutoFormInputComponentProps>>;
+    /**
+     * Localization object for the CMS plugin
+     */
+    localization?: Partial<CMSLocalization>;
+    /**
+     * Whether to show the attribution
+     */
+    showAttribution?: boolean;
+    /**
+     * Called when a route is rendered
+     * @param routeName - Name of the route (e.g., 'dashboard', 'contentList', 'contentEditor')
+     * @param context - Route context with path, params, etc.
+     */
+    onRouteRender?: (routeName: string, context: RouteContext) => void | Promise<void>;
+    /**
+     * Called when a route encounters an error
+     * @param routeName - Name of the route
+     * @param error - The error that occurred
+     * @param context - Route context
+     */
+    onRouteError?: (routeName: string, error: Error, context: RouteContext) => void | Promise<void>;
+}
+
+/**
+ * Context passed to loader hooks
+ */
+interface LoaderContext {
+    /** Current route path */
+    path: string;
+    /** Route parameters (e.g., { typeSlug: "product", id: "123" }) */
+    params?: Record<string, string>;
+    /** Whether rendering on server (true) or client (false) */
+    isSSR: boolean;
+    /** Base URL for API calls */
+    apiBaseURL: string;
+    /** Path where the API is mounted */
+    apiBasePath: string;
+    /** Optional headers for the request */
+    headers?: Headers;
+    /** Additional context properties */
+    [key: string]: unknown;
+}
+/**
+ * Hooks for CMS client plugin
+ * All hooks are optional and allow consumers to customize behavior
+ */
+interface CMSClientHooks {
+    /**
+     * Called before loading the dashboard page. If it throws, remaining loader
+     * work stops, `onErrorLoad` is notified, and the loader still resolves.
+     * @param context - Loader context with path, params, etc.
+     */
+    beforeLoadDashboard?: (context: LoaderContext) => Promise<void> | void;
+    /**
+     * Called after the dashboard is loaded.
+     * @param context - Loader context
+     */
+    afterLoadDashboard?: (context: LoaderContext) => Promise<void> | void;
+    /**
+     * Called before loading a content list page. If it throws, remaining loader
+     * work stops, `onErrorLoad` is notified, and the loader still resolves.
+     * @param typeSlug - The content type slug
+     * @param context - Loader context
+     */
+    beforeLoadContentList?: (typeSlug: string, context: LoaderContext) => Promise<void> | void;
+    /**
+     * Called after a content list is loaded.
+     * @param typeSlug - The content type slug
+     * @param context - Loader context
+     */
+    afterLoadContentList?: (typeSlug: string, context: LoaderContext) => Promise<void> | void;
+    /**
+     * Called before loading the content editor page. If it throws, remaining
+     * loader work stops, `onErrorLoad` is notified, and the loader still resolves.
+     * @param typeSlug - The content type slug
+     * @param id - The content item ID (undefined for new items)
+     * @param context - Loader context
+     */
+    beforeLoadContentEditor?: (typeSlug: string, id: string | undefined, context: LoaderContext) => Promise<void> | void;
+    /**
+     * Called after the content editor is loaded.
+     * @param typeSlug - The content type slug
+     * @param id - The content item ID (undefined for new items)
+     * @param context - Loader context
+     */
+    afterLoadContentEditor?: (typeSlug: string, id: string | undefined, context: LoaderContext) => Promise<void> | void;
+    /**
+     * Called when a loading error occurs.
+     * This is a reporting-only observer. Callback errors are contained and the
+     * loader never rejects, so throwing framework redirects are not supported.
+     * @param error - The error that occurred
+     * @param context - Loader context
+     */
+    onErrorLoad?: (error: Error, context: LoaderContext) => Promise<void> | void;
+}
+/**
+ * CMS-specific client configuration. Shared API, site, query-client, and
+ * request-header values are inherited from `createClientStack()`.
+ */
+interface CMSClientConfig {
+    /**
+     * Content types declared by this application. The HTTP contract remains the
+     * data source; this list preserves the developer-defined order in CMS pages.
+     * Omit it when a separately managed backend owns the catalog.
+     */
+    contentTypes?: readonly ContentTypeConfig[];
+    /** Optional hooks for route loading, error reporting, and telemetry. */
+    hooks?: CMSClientHooks;
+    /**
+     * Optional page component overrides.
+     * Replace any plugin page with a custom React component.
+     * The built-in component is used as the fallback when not provided.
+     */
+    pageComponents?: {
+        /** Replaces the CMS dashboard page */
+        dashboard?: ComponentType;
+        /** Replaces the content list page */
+        contentList?: ComponentType<{
+            params: {
+                typeSlug: string;
+            };
+        }>;
+        /** Replaces the new content editor page */
+        newContent?: ComponentType<{
+            params: {
+                typeSlug: string;
+            };
+        }>;
+        /** Replaces the edit content editor page */
+        editContent?: ComponentType<{
+            params: {
+                typeSlug: string;
+                id: string;
+            };
+        }>;
+    };
+}
+/**
+ * CMS client plugin
+ * Provides routes and components for the CMS admin interface.
+ *
+ * @param config - Optional CMS-specific behavior and page choices.
+ */
+declare const cmsClientPlugin: (config?: CMSClientConfig) => _btst_stack_client.ClientPluginDefinition<CMSPluginOverrides, {
+    dashboard: _btst_yar.DefinedRoute<"/cms", {
+        readonly page: react.LazyExoticComponent<typeof DashboardPageComponent>;
+        readonly loader: () => Promise<void>;
+        readonly meta: () => ({
+            title: string;
+            name?: undefined;
+            content?: undefined;
+        } | {
+            name: string;
+            content: string;
+            title?: undefined;
+        })[];
+    }, _btst_yar.RouteMeta>;
+    contentList: _btst_yar.DefinedRoute<"/cms/:typeSlug", {
+        readonly page: ({ params }: _btst_yar.RouteContext<"/cms/:typeSlug", _btst_yar.RouteOptions>) => react.JSX.Element;
+        readonly loader: ({ params }: _btst_yar.RouteContext<"/cms/:typeSlug", _btst_yar.RouteOptions>) => Promise<void>;
+        readonly meta: ({ params }: _btst_yar.RouteContext<"/cms/:typeSlug", _btst_yar.RouteOptions>) => ({
+            title: string;
+            name?: undefined;
+            content?: undefined;
+        } | {
+            name: string;
+            content: string;
+            title?: undefined;
+        })[];
+    }, _btst_yar.RouteMeta>;
+    newContent: _btst_yar.DefinedRoute<"/cms/:typeSlug/new", {
+        readonly page: ({ params }: _btst_yar.RouteContext<"/cms/:typeSlug/new", _btst_yar.RouteOptions>) => react.JSX.Element;
+        readonly loader: ({ params }: _btst_yar.RouteContext<"/cms/:typeSlug/new", _btst_yar.RouteOptions>) => Promise<void>;
+        readonly meta: ({ params }: _btst_yar.RouteContext<"/cms/:typeSlug/new", _btst_yar.RouteOptions>) => ({
+            title: string;
+            name?: undefined;
+            content?: undefined;
+        } | {
+            name: string;
+            content: string;
+            title?: undefined;
+        })[];
+    }, _btst_yar.RouteMeta>;
+    editContent: _btst_yar.DefinedRoute<"/cms/:typeSlug/:id", {
+        readonly page: ({ params }: _btst_yar.RouteContext<"/cms/:typeSlug/:id", _btst_yar.RouteOptions>) => react.JSX.Element;
+        readonly loader: ({ params }: _btst_yar.RouteContext<"/cms/:typeSlug/:id", _btst_yar.RouteOptions>) => Promise<void>;
+        readonly meta: ({ params }: _btst_yar.RouteContext<"/cms/:typeSlug/:id", _btst_yar.RouteOptions>) => ({
+            title: string;
+            name?: undefined;
+            content?: undefined;
+        } | {
+            name: string;
+            content: string;
+            title?: undefined;
+        })[];
+    }, _btst_yar.RouteMeta>;
+}, "cms", {
+    contentTypes?: readonly ContentTypeConfig[] | undefined;
+}, never>;
+
+interface FormStep {
+    id: string;
+    title: string;
+}
+interface FormSchemaMetadata {
+    /** Multi-step form step definitions */
+    steps?: FormStep[];
+    /** Map of field names to their step indices */
+    stepGroupMap?: Record<string, number>;
+}
+interface JsonSchemaProperty {
+    type?: string;
+    format?: string;
+    formatMinimum?: string;
+    formatMaximum?: string;
+    stepGroup?: number;
+    properties?: Record<string, JsonSchemaProperty>;
+    [key: string]: unknown;
+}
+interface FormJsonSchema {
+    type?: string;
+    properties?: Record<string, JsonSchemaProperty>;
+    required?: string[];
+    steps?: FormStep[];
+    stepGroupMap?: Record<string, number>;
+    [key: string]: unknown;
+}
+/**
+ * Convert a Zod schema to JSON Schema with proper handling for:
+ * - z.date() → { type: "string", format: "date-time" }
+ * - Date min/max constraints → formatMinimum/formatMaximum
+ * - Steps metadata (if provided via schema.meta() or explicit metadata param)
+ *
+ * @param schema - The Zod schema to convert
+ * @param metadata - Optional explicit metadata to include (overrides schema meta)
+ */
+declare function zodToFormSchema<T extends z$1.ZodType>(schema: T, metadata?: FormSchemaMetadata): FormJsonSchema;
+/**
+ * Convert JSON Schema to Zod schema with proper handling for:
+ * - { type: "string", format: "date-time" } → date field (with constraints)
+ * - Steps metadata re-attachment (preserved via .meta())
+ * - Step group mapping
+ *
+ * @param jsonSchema - The JSON Schema to convert
+ * @returns A Zod schema ready for validation, with all metadata preserved
+ */
+declare function formSchemaToZod(jsonSchema: FormJsonSchema): z$1.ZodType;
+/**
+ * Check if a JSON Schema has multi-step configuration.
+ */
+declare function hasSteps(jsonSchema: FormJsonSchema): boolean;
+/**
+ * Get steps from a JSON Schema.
+ */
+declare function getSteps(jsonSchema: FormJsonSchema): FormStep[];
+/**
+ * Get the step group map from a JSON Schema.
+ * Returns a map of field names to step indices.
+ */
+declare function getStepGroupMap(jsonSchema: FormJsonSchema): Record<string, number>;
+
+/**
+ * Props for the CMSFileUpload component
+ */
+interface CMSFileUploadProps extends AutoFormInputComponentProps {
+    /**
+     * Function to upload an image file and return the URL.
+     * This is required - consumers must provide an upload implementation.
+     */
+    uploadImage: (file: File) => Promise<string>;
+    /**
+     * Optional custom component for the image field.
+     * When provided, it replaces the default file-upload input entirely.
+     */
+    imageInputField?: ComponentType<{
+        value: string;
+        onChange: (value: string) => void;
+        isRequired?: boolean;
+    }>;
+    /**
+     * Optional trigger component for a media picker.
+     * When provided, it is rendered as a "Browse media" option.
+     */
+    imagePicker?: ComponentType<{
+        onSelect: (url: string) => void;
+    }>;
+}
+/**
+ * Default file upload component for CMS image fields.
+ *
+ * This component:
+ * - Accepts image files via file input
+ * - Uses the required uploadImage prop to upload and get a URL
+ * - Shows a preview of the uploaded image
+ * - Allows removing the uploaded image
+ *
+ * You can use this component directly in your fieldComponents override,
+ * or create your own custom component using this as a reference.
+ *
+ * @example
+ * ```tsx
+ * // Use the default component with your upload function
+ * fieldComponents: {
+ *   file: (props) => (
+ *     <CMSFileUpload {...props} uploadImage={myUploadFn} />
+ *   ),
+ * }
+ * ```
+ */
+declare function CMSFileUpload({ label, isRequired, fieldConfigItem, fieldProps, field, uploadImage, imageInputField: ImageInputField, imagePicker: ImagePickerTrigger, }: CMSFileUploadProps): react.JSX.Element;
+
+export { CMSFileUpload, ContentTypeConfig, cmsClientPlugin, formSchemaToZod, getStepGroupMap, getSteps, hasSteps, zodToFormSchema };
+export type { AutoFormInputComponentProps, CMSClientConfig, CMSClientHooks, CMSFileUploadProps, CMSLocalization, CMSPluginOverrides, CMSProviderConfig, FormSchemaMetadata, FormStep, LoaderContext, RouteContext };

package/dist/client/index.mjs

@@ -0,0 +1,3 @@
+export { cmsClientPlugin } from './plugin.mjs';
+export { formSchemaToZod, getStepGroupMap, getSteps, hasSteps, zodToFormSchema } from '../ui/src/lib/schema-converter.mjs';
+export { CMSFileUpload } from './components/forms/file-upload.mjs';

package/dist/client/overrides.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+function orderCMSContentTypes(contentTypes, providerConfig) {
+  const configured = providerConfig?.contentTypes;
+  if (!Array.isArray(configured) || configured.length === 0) {
+    return [...contentTypes];
+  }
+  const positions = /* @__PURE__ */ new Map();
+  for (const [index, value] of configured.entries()) {
+    if (value !== null && typeof value === "object" && "slug" in value && typeof value.slug === "string") {
+      positions.set(value.slug, index);
+    }
+  }
+  return contentTypes.map((value, index) => ({ value, index })).sort((left, right) => {
+    const leftPosition = positions.get(left.value.slug);
+    const rightPosition = positions.get(right.value.slug);
+    if (leftPosition === void 0 && rightPosition === void 0) {
+      return left.index - right.index;
+    }
+    if (leftPosition === void 0) return 1;
+    if (rightPosition === void 0) return -1;
+    return leftPosition - rightPosition;
+  }).map(({ value }) => value);
+}
+
+exports.orderCMSContentTypes = orderCMSContentTypes;