import { ReactNode } from 'react';
import { Schema as Schema_2 } from 'effect';

/**
 * Compute every `derivedFrom` field from its source value. Returns a NEW
 * row — the input is not mutated. A caller-provided value for a derived
 * field is OVERWRITTEN (derived values are the content type's opinion,
 * mirroring the column `.computed()` semantics). Derivations run in
 * declaration order against the progressively-updated row, so a derived
 * field may source another, earlier-declared derived field.
 */
export declare const applyDerivations: (type: Pick<ContentType, "fields" | "derivedFields">, row: Readonly<Record<string, unknown>>) => Record<string, unknown>;

/** Everything the write pipeline can fail with on the typed channel. */
export declare type CmsWriteError = ContentValidationFailed | ContentNotFound | ContentIdConflict;

/**
 * Auto-generated content form. Renders one labelled widget per field,
 * driven entirely by each field's `editorHint`. Stateless — the caller
 * owns `value` + `onChange`.
 */
export declare const ContentForm: (props: ContentFormProps) => ReactNode;

export declare interface ContentFormProps {
    readonly contentType: ContentFormType;
    readonly value: ContentValue;
    readonly onChange: (next: ContentValue) => void;
    /** Override the widget for one or more editor hints (e.g. a TipTap richText). */
    readonly widgets?: Partial<Record<EditorHint, Widget>>;
}

/** The content-type shape ContentForm reads (structural — avoids a value import). */
export declare interface ContentFormType {
    readonly fields: Readonly<Record<string, FieldSchema>>;
}

/**
 * Raised by `saveDraft` when the caller supplies an explicit `id` that
 * already exists OUTSIDE the caller's scope (another tenant's row).
 * Refusing here keeps a caller-pinned id from ever updating — or, on a
 * store without DB-enforced PKs, overwriting — a foreign row.
 */
export declare class ContentIdConflict extends ContentIdConflict_base {
}

declare const ContentIdConflict_base: Schema_2.TaggedErrorClass<ContentIdConflict, "ContentIdConflict", {
    readonly _tag: Schema_2.tag<"ContentIdConflict">;
} & {
    contentType: typeof Schema_2.String;
    id: typeof Schema_2.String;
}>;

/**
 * Raised by `publish` / `unpublish` / `archive` when the row id doesn't
 * exist in the caller's scope. On a tenant-scoped request store this is
 * ALSO the cross-tenant answer: another tenant's row is indistinguishable
 * from a missing one (the scoped read never sees it).
 */
export declare class ContentNotFound extends ContentNotFound_base {
}

declare const ContentNotFound_base: Schema_2.TaggedErrorClass<ContentNotFound, "ContentNotFound", {
    readonly _tag: Schema_2.tag<"ContentNotFound">;
} & {
    contentType: typeof Schema_2.String;
    id: typeof Schema_2.String;
    /** Which lifecycle table the id was looked up in. */
    stage: Schema_2.Literal<["draft", "published"]>;
}>;

/** A registered content type. */
declare interface ContentType {
    readonly name: string;
    readonly displayName: string;
    readonly pluralName: string;
    readonly fields: Readonly<Record<string, FieldSchema>>;
    readonly list?: ListConfig;
    readonly idPrefix?: string;
    /** Declared ISR revalidations fired on publish/unpublish — see
     *  `ContentTypeSpec.revalidate`. */
    readonly revalidate?: ContentTypeSpec['revalidate'];
    /** Field names whose value is computed-on-save (derivedFrom). */
    readonly derivedFields: ReadonlyArray<string>;
    /** Field names marked unique-per-tenant (composite `(tenantId, field)` UNIQUE). */
    readonly uniqueFields: ReadonlyArray<string>;
}

/** The user-authored spec passed to `defineContentType`. */
declare interface ContentTypeSpec {
    readonly name: string;
    readonly displayName: string;
    readonly pluralName: string;
    readonly fields: Readonly<Record<string, FieldSchema | PipeableField>>;
    readonly list?: ListConfig;
    /** Override the TypeID prefix for awkward plurals / long names. */
    readonly idPrefix?: string;
    /**
     * ISR routes to drop when content of this type is published or
     * unpublished — `publish()`/`unpublish()` call `revalidatePath` /
     * `revalidateTag` (from `@voltro/runtime`) for each entry after the
     * write commits, reaching every `voltro start` replica.
     *
     * You DON'T need this on postgres for the plain publish case: a route
     * declaring `cacheInvalidatesOn: ['<type>_published']` is already dropped
     * by CDC when the published table changes. Declare routes here for the
     * cases CDC can't cover — non-postgres dialects, pattern purges of routes
     * whose loader reads this content indirectly, or tag fanout.
     */
    readonly revalidate?: {
        /** Route patterns (`/blog/[slug]`) or concrete paths (`/pricing`). */
        readonly paths?: ReadonlyArray<string>;
        /** Tags matched against routes' `cacheInvalidatesOn` entries. */
        readonly tags?: ReadonlyArray<string>;
    };
}

/**
 * Raised by `validateContent` / `saveDraft` when a row violates the
 * content type's field rules (pattern / maxLength / typed kinds /
 * literal sets / rich-text content policy). Carries EVERY violation,
 * per field, so an editor can annotate the whole form in one pass.
 */
export declare class ContentValidationFailed extends ContentValidationFailed_base {
}

declare const ContentValidationFailed_base: Schema_2.TaggedErrorClass<ContentValidationFailed, "ContentValidationFailed", {
    readonly _tag: Schema_2.tag<"ContentValidationFailed">;
} & {
    contentType: typeof Schema_2.String;
    violations: Schema_2.Array$<Schema_2.Struct<{
        field: typeof Schema_2.String;
        rule: typeof Schema_2.String;
        message: typeof Schema_2.String;
    }>>;
}>;

export declare type ContentValue = Record<string, unknown>;

/**
 * Collect every save-time rule violation for `row` against `type` —
 * required presence, per-kind type checks, `maxLength`, `pattern`,
 * `Literal` value sets, and the rich-text content policy
 * (`allowImages` / `allowEmbeds: false` reject image/embed nodes or the
 * `<img>` / `<iframe>` / `<embed>` markers in string values).
 *
 * Pure and never throws — usable in a browser form ("annotate every
 * invalid field") as well as on the server. `id` is allowed (must be a
 * string); the lifecycle/mixin columns the pipeline owns (`status`,
 * `tenantId`, audit who/when) are tolerated on input and ignored; any
 * OTHER undeclared key is an `unknown` violation (usually a typo'd
 * field name).
 *
 * NOTE on ordering: run `applyDerivations` first when validating a row
 * that is about to be written — a derived field's rules apply to the
 * derived value, not to a caller value that's about to be overwritten.
 */
export declare const contentViolations: (type: Pick<ContentType, "name" | "fields">, row: Readonly<Record<string, unknown>>) => ReadonlyArray<FieldViolation>;

/**
 * Mark a field computed-on-save from another field. The transform runs
 * before the row is written — `saveDraft` applies it (via
 * `applyDerivations`) ahead of validation, and `publish` copies the
 * derived value. A caller-provided value is overwritten, mirroring the
 * column `.computed()` semantics.
 *
 * ```ts
 * slug: Schema.String.pipe(pattern(/^[a-z0-9-]+$/), derivedFrom('title', slugify))
 * ```
 */
export declare const derivedFrom: (source: string, transform: (value: unknown, row: Record<string, unknown>) => unknown) => FieldRefinement;

/** A field marked computed-on-save from another field's value. */
export declare interface DerivedSpec {
    readonly source: string;
    readonly transform: (value: unknown, row: Record<string, unknown>) => unknown;
}

/** The widget the editor renders for a field — drives ContentForm. */
export declare type EditorHint = 'text' | 'textarea' | 'number' | 'boolean' | 'date' | 'datetime' | 'select' | 'richText' | 'media' | 'reference' | 'array' | 'struct';

/** Discriminator for how a field compiles to a column + serialises. */
export declare type FieldKind = 'string' | 'number' | 'boolean' | 'date' | 'datetime' | 'literal' | 'richText' | 'media' | 'reference' | 'array' | 'struct';

/** A refinement applied through `.pipe(...)`. */
export declare type FieldRefinement = (field: FieldSchema) => FieldSchema;

/** A fully-resolved field descriptor stored on a content type. */
export declare interface FieldSchema {
    readonly kind: FieldKind;
    readonly editorHint: EditorHint;
    /** When true the field is nullable in the DB + optional in the editor. */
    readonly isOptional: boolean;
    /** Max string length — drives textarea-vs-input + save-time validation. */
    readonly maxLength?: number;
    /** Source-form regex (string) for save-time validation. */
    readonly pattern?: string;
    /** Closed value set for `literal` fields → `<select>` + CHECK constraint. */
    readonly literals?: ReadonlyArray<string>;
    /**
     * When true, the field is unique PER TENANT — the derived tables carry a
     * composite `(tenantId, <field>)` DB UNIQUE constraint (see contentType.ts).
     * Only meaningful on a `string` field (typically a slug).
     */
    readonly unique?: boolean;
    /** RichText options. */
    readonly richText?: RichTextOptions;
    /** Referenced content-type name for `reference` fields. */
    readonly referenceType?: string;
    /** Element field for `array` fields. */
    readonly element?: FieldSchema;
    /** Nested field map for `struct` fields. */
    readonly struct?: Readonly<Record<string, FieldSchema>>;
    /** Computed-on-save derivation (set via `derivedFrom`). */
    readonly derived?: DerivedSpec;
}

/** One save-time rule violation, addressed to a field path. */
export declare interface FieldViolation {
    /** Dotted/indexed field path, e.g. `title`, `meta.ogTitle`, `tags[2]`. */
    readonly field: string;
    /** The rule that failed: `required` | `type` | `maxLength` | `pattern` | `literal` | `richText` | `unknown`. */
    readonly rule: string;
    readonly message: string;
}

/**
 * List-view configuration for the consuming editor/template: which
 * columns its list page shows and the default sort. Validated by
 * `defineContentType` — every referenced name must be a declared field
 * or a lifecycle column, so a typo fails at definition time instead of
 * rendering an empty column.
 */
declare interface ListConfig {
    readonly columns: ReadonlyArray<string>;
    readonly defaultSort?: {
        readonly field: string;
        readonly dir: 'asc' | 'desc';
    };
}

/** Cap a string field's length. Past `value` the editor renders a textarea. */
export declare const maxLength: (value: number) => FieldRefinement;

/** Constrain a string field to a regex (source form, validated on save). */
export declare const pattern: (re: RegExp) => FieldRefinement;

export declare interface PipeableField extends FieldSchema {
    readonly isOptional: boolean;
    pipe(...refinements: ReadonlyArray<FieldRefinement>): PipeableField;
    /** Mark the field optional → nullable column + non-required editor input. */
    optional(): PipeableField;
}

/**
 * Options carried by a RichText field, enforced at save time by
 * `validateContent`: an explicit `false` REJECTS the content class
 * (image/embed nodes in a structured document, or `<img>` / `<iframe>` /
 * `<embed>` markers in a string value); `true` or omitted allows it.
 */
export declare interface RichTextOptions {
    readonly allowImages?: boolean;
    readonly allowEmbeds?: boolean;
}

/**
 * The CMS field namespace. Scalars mirror the effect/Schema names the
 * docs use; the CMS-only constructors (RichText / Media / Reference /
 * Array / Struct) carry their editor metadata. `optional()` is exposed
 * as a property accessor on each scalar through the underlying field.
 */
export declare const Schema: {
    /** Single-line text. `.pipe(maxLength(N>120))` switches it to a textarea. */
    readonly String: PipeableField;
    /** Numeric input. */
    readonly Number: PipeableField;
    /** Toggle. */
    readonly Boolean: PipeableField;
    /** Date-only picker. */
    readonly Date: PipeableField;
    /** Date + time picker. */
    readonly DateTime: PipeableField;
    readonly maxLength: (value: number) => FieldRefinement;
    readonly pattern: (re: RegExp) => FieldRefinement;
    readonly unique: () => FieldRefinement;
    /** Closed value set → `<select>` widget + a CHECK constraint. */
    readonly Literal: (values_0: string, ...values: string[]) => PipeableField;
    /**
     * Rich text, stored as a JSON document (e.g. a TipTap doc). The shipped
     * default widget is a plain textarea placeholder — swap in a real editor
     * via the `ContentForm` `widgets` override. `allowImages` /
     * `allowEmbeds: false` reject that content class at save time.
     */
    readonly RichText: (options?: RichTextOptions) => PipeableField;
    /**
     * A storage object key (e.g. one issued by `@voltro/plugin-storage`),
     * stored as text. Resolve the key to a served URL after a read with
     * `resolveMedia(type, row, resolver)` — the app supplies the resolver
     * (built from its storage layer's `getUrl`/`mintUrl`), so the core
     * package stays decoupled from any storage plugin.
     */
    readonly Media: () => PipeableField;
    /** A reference to another content type's published rows. */
    readonly Reference: (type: string) => PipeableField;
    /** Repeatable field. Stored as a JSON array. */
    readonly Array: (element: FieldSchema) => PipeableField;
    /** Nested object. Stored as a JSON document. */
    readonly Struct: (fields: Readonly<Record<string, FieldSchema>>) => PipeableField;
};

/** The canonical slug helper: lowercase, hyphenate, strip non-url chars. */
export declare const slugify: (value: unknown) => string;

/**
 * Mark a string field unique PER TENANT. The derived `<type>_drafts` +
 * `<type>_published` tables get a real composite `(tenantId, <field>)`
 * DB UNIQUE constraint (the tenant() mixin's `tenantId` is NOT NULL, so
 * no partial/NULL machinery is needed) — the database rejects a second
 * row with the same slug in the same tenant, not the application. Pair it
 * with `derivedFrom('title', slugify)` for a per-tenant-unique slug.
 */
export declare const unique: () => FieldRefinement;

/**
 * Validate a row against a content type's save-time rules. Throws
 * `ContentValidationFailed` carrying EVERY violation (per-field detail)
 * when any rule breaks; returns nothing on success. The throwing face of
 * `contentViolations` — `saveDraft` calls this after derivation.
 */
export declare const validateContent: (type: Pick<ContentType, "name" | "fields">, row: Readonly<Record<string, unknown>>) => void;

export declare type Widget = (props: WidgetProps) => ReactNode;

/** Resolve the widget for a field, honouring `widgets` overrides. */
export declare const widgetFor: (hint: EditorHint, overrides?: Partial<Record<EditorHint, Widget>>) => Widget;

/** Props for a single field widget. */
export declare interface WidgetProps {
    readonly name: string;
    readonly field: FieldSchema;
    readonly value: unknown;
    readonly onChange: (value: unknown) => void;
}

export { }