@nextlyhq/plugin-form-builder 0.0.2-alpha.7 → 0.0.2-alpha.71

package/dist/types-BHReIA0j.d.ts

@@ -0,0 +1,986 @@
+import { CollectionConfig, FieldDefinition, RequestContext } from "nextly";
+import { ComponentType } from "react";
+/**
+ * Reading the document a form's redirect setting points at.
+ *
+ * Separate from `redirect-target` because this half has no dependencies and
+ * the other half imports `nextly/config`: the admin picker needs to read a
+ * stored reference to show what is selected, and pulling the config surface
+ * into the browser bundle to do it would be a real cost for no gain.
+ */
+/** A document being turned into a URL. `id` is always present; the rest is the row. */
+interface RedirectTargetDocument {
+  id: string;
+  [field: string]: unknown;
+}
+/**
+ * How documents in one collection become URLs.
+ *
+ * A string is a path with `{field}` placeholders filled from the document.
+ * A function receives the document and returns the path itself.
+ */
+type RedirectUrlPattern = string | ((document: RedirectTargetDocument) => string | undefined);
+/** The collection-to-pattern map, after the array shorthand is normalised. */
+type RedirectRelationships = Record<string, RedirectUrlPattern>;
+/**
+ * Configuration for customizing field block behavior.
+ */
+interface FieldBlockConfig {
+  /** Default label for this field type */
+  label?: string;
+  /** Default validation settings */
+  validation?: Record<string, unknown>;
+  /** Custom component to use for this field type */
+  component?: ComponentType<unknown>;
+}
+/**
+ * Email configuration for notifications.
+ */
+interface EmailConfig {
+  to: string | string[];
+  from?: string;
+  subject: string;
+  html?: string;
+  text?: string;
+  replyTo?: string;
+  cc?: string | string[];
+  bcc?: string | string[];
+}
+/**
+ * @experimental A resolved outgoing form notification (template-based) as built
+ * by the submission handler, before it is sent. This is the value transformed by
+ * the `form-builder.beforeEmail` D63 filter seam.
+ */
+interface FormEmailNotification {
+  /** Resolved recipient address. */
+  to: string;
+  /** Email template slug to render. */
+  templateSlug: string;
+  /** Template variables (submitted data + form metadata). */
+  variables: Record<string, unknown>;
+  /** Email provider id; undefined = system default. */
+  providerId?: string;
+  /**
+   * Resolved sender address (rule's senderEmail, else the plugin's
+   * defaultFrom); undefined = template/provider default.
+   */
+  from?: string;
+  /** Resolved Reply-To address, if the rule configured one. */
+  replyTo?: string;
+  /** CC addresses, if any. */
+  cc?: string[];
+  /** BCC addresses, if any. */
+  bcc?: string[];
+  /** Source notification id; undefined for filter-injected emails. */
+  notificationId?: string;
+}
+/**
+ * A single email notification rule stored on a form.
+ * Matches the shape saved by the form builder admin UI. This is the ONE
+ * notification rule type — the admin context re-exports it rather than
+ * keeping a parallel copy.
+ */
+interface FormNotification {
+  /** Unique ID for this notification */
+  id: string;
+  /** Display name for this notification rule */
+  name: string;
+  /** Whether this notification is active */
+  enabled: boolean;
+  /** ID of the email provider to use; undefined = system default */
+  providerId?: string;
+  /**
+   * Sender email override. Resolution order at send time:
+   * this value, else the plugin's `notifications.defaultFrom` option, else
+   * the template/provider default.
+   */
+  senderEmail?: string;
+  /** How the recipient address is determined */
+  recipientType: "static" | "field";
+  /** Recipient: static email address or a {{fieldName}} reference */
+  to: string;
+  /** CC email addresses */
+  cc: string[];
+  /** BCC email addresses */
+  bcc: string[];
+  /**
+   * Reply-To address: a `{{fieldName}}` reference to one of the form's
+   * email fields (resolved against the submission) or a literal address.
+   */
+  replyTo?: string;
+  /**
+   * Optional send condition evaluated against the submitted data. When set
+   * and unmet, the rule is skipped for that submission. A single condition
+   * covers the common case; the JSON storage leaves room to grow into a
+   * multi-condition tree without a migration.
+   */
+  condition?: ConditionalLogicCondition;
+  /** Slug of the email template to use */
+  templateSlug?: string;
+}
+/**
+ * @deprecated Use {@link FormNotification}. Alias kept so existing imports
+ * keep compiling during the alpha; will be removed before a stable release.
+ */
+type FormNotificationItem = FormNotification;
+/**
+ * Form document structure (stored in database).
+ */
+interface FormDocument {
+  id: string;
+  slug: string;
+  name: string;
+  fields: AnyFormField[];
+  settings: FormSettings;
+  notifications: FormNotification[];
+  status: "draft" | "published" | "closed";
+  /**
+   * What a closed form tells a visitor who reaches it.
+   *
+   * Optional because the field is only written once an author has a reason to
+   * give, and a row created before it existed has none. A closed form with
+   * nothing here falls back to the generic refusal, which is also what a draft
+   * gets — a draft has never been public, so there is no author intent to
+   * relay.
+   */
+  closedMessage?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+/**
+ * Submission document structure (stored in database).
+ */
+interface SubmissionDocument {
+  id: string;
+  form: string | FormDocument;
+  data: Record<string, unknown>;
+  /**
+   * Where the submission sits in review.
+   *
+   * `spam` is one of them, not a separate flag: the stored field offers it, the
+   * admin has a Spam tab and filters the other views with `not_equals: "spam"`,
+   * the notification hook skips it, and marking something "Not spam" moves it
+   * back to `new`. `spamReason` records WHICH check flagged it.
+   */
+  status: "new" | "read" | "archived" | "spam";
+  ipAddress?: string;
+  userAgent?: string;
+  /** Which spam check flagged this, when one did. */
+  spamReason?: string | null;
+  submittedAt: Date;
+  createdAt: Date;
+  updatedAt: Date;
+}
+/**
+ * Configuration options for the form builder plugin.
+ */
+/**
+ * Which field types the builder offers, and how each one is customised.
+ *
+ * Declared ONCE and viewed twice: the options surface takes
+ * `Partial<FormFieldToggles>` and the resolved config takes it whole, because
+ * "resolved" means exactly "every toggle now has a value". Written out twice
+ * the two lists agree until someone adds a field type to one of them.
+ */
+interface FormFieldToggles {
+  text: boolean | Partial<FieldBlockConfig>;
+  email: boolean | Partial<FieldBlockConfig>;
+  number: boolean | Partial<FieldBlockConfig>;
+  phone: boolean | Partial<FieldBlockConfig>;
+  url: boolean | Partial<FieldBlockConfig>;
+  textarea: boolean | Partial<FieldBlockConfig>;
+  select: boolean | Partial<FieldBlockConfig>;
+  checkbox: boolean | Partial<FieldBlockConfig>;
+  radio: boolean | Partial<FieldBlockConfig>;
+  file: boolean | Partial<FieldBlockConfig>;
+  date: boolean | Partial<FieldBlockConfig>;
+  time: boolean | Partial<FieldBlockConfig>;
+  hidden: boolean | Partial<FieldBlockConfig>;
+}
+/** What a host may override on a collection this plugin contributes. */
+type CollectionOverrides = Partial<CollectionConfig> & {
+  slug?: string;
+  labels?: {
+    singular?: string;
+    plural?: string;
+  };
+  /** Fields can be an array or a function receiving defaultFields */
+  fields?: FieldDefinition[] | ((args: {
+    defaultFields: FieldDefinition[];
+  }) => FieldDefinition[]);
+};
+/** The same, once the plugin's defaults have filled in what a host omitted. */
+type ResolvedCollectionOverrides = {
+  slug: string;
+  labels: {
+    singular: string;
+    plural: string;
+  };
+} & Partial<CollectionConfig>;
+interface FormBuilderPluginOptions {
+  /**
+   * Override the default Forms collection configuration.
+   *
+   * Allows customizing the slug, labels, fields, access control, and other
+   * collection options.
+   *
+   * The `fields` option can be:
+   * - An array of fields (merged with defaults)
+   * - A function receiving `{ defaultFields }` for full control
+   *
+   * @example
+   * ```typescript
+   * // Option 1: Array (fields merged with defaults)
+   * formOverrides: {
+   *   slug: 'my-forms',
+   *   labels: { singular: 'My Form', plural: 'My Forms' },
+   *   access: {
+   *     read: () => true,
+   *     // Narrow the permission, never replace it: the role screen still
+   *     // decides who holds `create-my-forms`.
+   *     create: ({ permissions }) =>
+   *       permissions.includes('create-my-forms') && process.env.CONTENT_FREEZE !== 'on',
+   *   },
+   *   fields: [
+   *     text({ name: 'internalNotes', label: 'Internal Notes' }),
+   *   ],
+   * }
+   *
+   * // Option 2: Function (full control over fields)
+   * formOverrides: {
+   *   slug: 'contact-forms',
+   *   access: {
+   *     read: ({ permissions }) => permissions.includes('read-contact-forms'),
+   *     update: () => false,
+   *   },
+   *   fields: ({ defaultFields }) => {
+   *     return [
+   *       ...defaultFields,
+   *       { name: 'custom', type: 'text' },
+   *     ];
+   *   },
+   * }
+   * ```
+   */
+  formOverrides?: CollectionOverrides;
+  /**
+   * Override the default Form Submissions collection configuration.
+   *
+   * Allows customizing the slug, labels, fields, access control, and other
+   * collection options.
+   *
+   * The `fields` option can be:
+   * - An array of fields (merged with defaults)
+   * - A function receiving `{ defaultFields }` for full control
+   *
+   * @example
+   * ```typescript
+   * // Option 1: Array (fields merged with defaults)
+   * formSubmissionOverrides: {
+   *   slug: 'my-submissions',
+   *   labels: { singular: 'Response', plural: 'Responses' },
+   *   access: {
+   *     read: ({ permissions }) => permissions.includes('read-my-submissions'),
+   *   },
+   *   fields: [
+   *     select({
+   *       name: 'priority',
+   *       label: 'Priority',
+   *       options: [
+   *         { label: 'Low', value: 'low' },
+   *         { label: 'High', value: 'high' },
+   *       ],
+   *     }),
+   *   ],
+   * }
+   *
+   * // Option 2: Function (full control over fields)
+   * formSubmissionOverrides: {
+   *   fields: ({ defaultFields }) => {
+   *     // Add field after 'form' field
+   *     const formIndex = defaultFields.findIndex(f => f.name === 'form');
+   *     return [
+   *       ...defaultFields.slice(0, formIndex + 1),
+   *       { name: 'source', type: 'text' },
+   *       ...defaultFields.slice(formIndex + 1),
+   *     ];
+   *   },
+   * }
+   * ```
+   */
+  formSubmissionOverrides?: CollectionOverrides;
+  /**
+   * Configure which field types are available in the form builder.
+   *
+   * Set to `false` to disable a field type, or provide partial configuration
+   * to customize default behavior.
+   *
+   * @example
+   * ```typescript
+   * fields: {
+   *   // Disable payment field
+   *   payment: false,
+   *
+   *   // Customize text field defaults
+   *   text: {
+   *     maxLength: 500,
+   *   },
+   *
+   *   // Disable file uploads
+   *   file: false,
+   * }
+   * ```
+   */
+  fields?: Partial<FormFieldToggles>;
+  /**
+   * Collections whose documents a form may redirect to after submission, and
+   * how each one's documents become URLs.
+   *
+   * The mapping is configuration because it cannot be derived: a site's URL
+   * structure belongs to the site. `{field}` placeholders are filled from the
+   * document; a function covers a path this package cannot express.
+   *
+   * The array shorthand names the collections and takes `/{slug}` for all of
+   * them, which is the routing the page builder ships.
+   *
+   * @example
+   * ```typescript
+   * redirectRelationships: ['pages']
+   *
+   * redirectRelationships: {
+   *   pages: '/{slug}',
+   *   posts: '/blog/{slug}',
+   *   docs: page => `/docs/${String(page.section)}/${String(page.slug)}`,
+   * }
+   * ```
+   */
+  redirectRelationships?: string[] | RedirectRelationships;
+  /**
+   * Hook called before sending email notifications.
+   *
+   * Runs as the `form-builder.beforeEmail` D63 filter: the resolved outgoing
+   * notifications (template + recipient + variables) are threaded through this
+   * callback before they are sent. Allows modifying, adding, or filtering the
+   * outgoing notifications. Return the modified array.
+   *
+   * @example
+   * ```typescript
+   * beforeEmail: async ({ emails, form, submission }) => {
+   *   // Add BCC to all outgoing notifications
+   *   return emails.map((e) => ({ ...e, bcc: ['archive@example.com'] }));
+   * }
+   * ```
+   */
+  beforeEmail?: (args: {
+    emails: FormEmailNotification[];
+    form: FormDocument;
+    submission: SubmissionDocument;
+  }) => Promise<FormEmailNotification[]> | FormEmailNotification[];
+  /**
+   * Email notification settings.
+   */
+  notifications?: {
+    /**
+     * Default "from" email address.
+     */
+    defaultFrom?: string;
+    /**
+     * Default "to" email address for all form submissions.
+     *
+     * If specified, this email will receive all form submissions
+     * regardless of form-specific notification settings.
+     * @example
+     * ```typescript
+     * notifications: {
+     *   defaultToEmail: 'submissions@example.com',
+     * }
+     * ```
+     */
+    defaultToEmail?: string;
+    /**
+     * Enable/disable email notifications globally.
+     * @default true
+     */
+    enabled?: boolean;
+  };
+  /**
+   * Spam protection configuration.
+   */
+  spamProtection?: {
+    /**
+     * Enable honeypot field for spam detection.
+     * @default true
+     */
+    honeypot?: boolean;
+    /**
+     * Enable reCAPTCHA v3.
+     * @default false
+     */
+    recaptcha?: {
+      enabled: boolean;
+      siteKey?: string;
+      secretKey?: string;
+      scoreThreshold?: number;
+    };
+    /**
+     * Rate limiting configuration.
+     */
+    rateLimit?: {
+      /**
+       * Maximum submissions per window.
+       * @default 10
+       */
+      maxSubmissions?: number;
+      /**
+       * Time window in milliseconds.
+       * @default 60000 (1 minute)
+       */
+      windowMs?: number;
+    };
+  };
+  /**
+   * File upload settings.
+   */
+  uploads?: {
+    /**
+     * Maximum file size in bytes.
+     * @default 10485760 (10MB)
+     */
+    maxFileSize?: number;
+    /**
+     * Allowed file types (MIME types).
+     * @default ['image/*', 'application/pdf', 'text/*']
+     */
+    allowedMimeTypes?: string[];
+    /**
+     * Collection to store uploaded files.
+     * @default 'media'
+     */
+    uploadCollection?: string;
+  };
+  /**
+   * Enable/disable features.
+   */
+  features?: {
+    /**
+     * Enable visual form builder UI.
+     * @default true
+     */
+    builder?: boolean;
+    /**
+     * Enable conditional logic.
+     * @default true
+     */
+    conditionalLogic?: boolean;
+    /**
+     * Enable file uploads.
+     * @default true
+     */
+    fileUploads?: boolean;
+  };
+}
+/**
+ * Form configuration interface.
+ * Similar to CollectionConfig but tailored for forms.
+ */
+interface FormConfig {
+  /**
+   * Unique identifier for the form.
+   */
+  slug: string;
+  /**
+   * Display labels for the form.
+   */
+  labels?: {
+    singular?: string;
+    plural?: string;
+  };
+  /**
+   * Form fields definition.
+   */
+  fields: AnyFormField[];
+  /**
+   * Form settings and behavior.
+   */
+  settings?: FormSettings;
+  /**
+   * Email notification configuration.
+   */
+  notifications?: FormNotifications;
+  /**
+   * Access control for form submission and viewing.
+   */
+  access?: FormAccess;
+  /**
+   * Lifecycle hooks for form submissions.
+   */
+  hooks?: FormHooks;
+  /**
+   * Custom metadata.
+   */
+  custom?: Record<string, unknown>;
+}
+/**
+ * Form field type (discriminated union).
+ * Uses the `type` property as the discriminant.
+ */
+type FormField = TextFormField | EmailFormField | NumberFormField | PhoneFormField | UrlFormField | TextareaFormField | SelectFormField | CheckboxFormField | RadioFormField | FileFormField | DateFormField | TimeFormField | HiddenFormField;
+/**
+ * A form field of a built-in type OR a plugin-contributed type. Stored form
+ * data and the builder work with this; `isKnownFormField` narrows it back to
+ * the closed `FormField` union so `switch (field.type)` keeps discriminating
+ * the built-ins (a `CustomFormField` in the union itself would collapse that).
+ */
+type AnyFormField = FormField | CustomFormField;
+/**
+ * All available built-in form field type identifiers.
+ */
+type FormFieldType = "text" | "email" | "number" | "phone" | "url" | "textarea" | "select" | "checkbox" | "radio" | "file" | "date" | "time" | "hidden";
+/**
+ * A form field's type on the wire: a built-in or a plugin-contributed type id
+ * that opted into the forms surface. The `(string & {})` arm admits the plugin
+ * id while keeping built-in autocomplete. Built-in `case` narrowing still works
+ * because every field-type switch keeps a `default` for the custom arm.
+ */
+type FormFieldTypeId = FormFieldType | (string & {});
+/** Every built-in form field type, as a value list (the single source shared
+ * by the field-type guard and the config validator). */
+declare const BUILT_IN_FORM_FIELD_TYPES: readonly FormFieldType[];
+/**
+ * Narrow an `AnyFormField` to the closed built-in `FormField` union. Returns
+ * `false` for a plugin-contributed field, so callers handle it generically
+ * before switching on the built-in discriminant.
+ */
+declare function isKnownFormField(field: AnyFormField): field is FormField;
+/**
+ * Base form field properties.
+ * All form field types extend this interface.
+ */
+interface BaseFormField {
+  /** Field type identifier (discriminant) */
+  type: FormFieldType;
+  /** Field name (used as key in submission data) */
+  name: string;
+  /** Display label */
+  label: string;
+  /** Placeholder text */
+  placeholder?: string;
+  /** Help text shown below field */
+  helpText?: string;
+  /** Default value */
+  defaultValue?: unknown;
+  /** Whether field is required */
+  required?: boolean;
+  /** Validation rules */
+  validation?: ValidationRules;
+  /** Conditional logic configuration */
+  conditionalLogic?: ConditionalLogic;
+  /** Admin UI configuration */
+  admin?: {
+    /** CSS classes */
+    className?: string;
+    /** Field width */
+    width?: "25%" | "33%" | "50%" | "66%" | "75%" | "100%";
+  };
+}
+/**
+ * A plugin-contributed form field type (outside the built-in union). Carries
+ * only the base properties — the plugin owns its editor component and value
+ * semantics — and its `type` is the plugin's registered field-type id. Kept a
+ * distinct union member so built-in `case` narrowing is unaffected while a
+ * plugin field still type-checks as a `FormField`.
+ */
+interface CustomFormField extends Omit<BaseFormField, "type"> {
+  type: string & {};
+}
+/**
+ * Text input field.
+ */
+interface TextFormField extends Omit<BaseFormField, "type"> {
+  type: "text";
+  defaultValue?: string;
+  validation?: ValidationRules & {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+  };
+}
+/**
+ * Email input field.
+ */
+interface EmailFormField extends Omit<BaseFormField, "type"> {
+  type: "email";
+  defaultValue?: string;
+  validation?: ValidationRules & {
+    pattern?: string;
+  };
+}
+/**
+ * Number input field.
+ */
+interface NumberFormField extends Omit<BaseFormField, "type"> {
+  type: "number";
+  defaultValue?: number;
+  validation?: ValidationRules & {
+    min?: number;
+    max?: number;
+    step?: number;
+  };
+}
+/**
+ * Phone input field.
+ */
+interface PhoneFormField extends Omit<BaseFormField, "type"> {
+  type: "phone";
+  defaultValue?: string;
+  validation?: ValidationRules & {
+    pattern?: string;
+  };
+}
+/**
+ * URL input field.
+ */
+interface UrlFormField extends Omit<BaseFormField, "type"> {
+  type: "url";
+  defaultValue?: string;
+  validation?: ValidationRules & {
+    pattern?: string;
+  };
+}
+/**
+ * Textarea field.
+ */
+interface TextareaFormField extends Omit<BaseFormField, "type"> {
+  type: "textarea";
+  defaultValue?: string;
+  rows?: number;
+  validation?: ValidationRules & {
+    minLength?: number;
+    maxLength?: number;
+  };
+}
+/**
+ * Select dropdown field.
+ */
+interface SelectFormField extends Omit<BaseFormField, "type"> {
+  type: "select";
+  options: Array<{
+    label: string;
+    value: string;
+  }>;
+  defaultValue?: string | string[];
+  allowMultiple?: boolean;
+}
+/**
+ * Single checkbox field.
+ */
+interface CheckboxFormField extends Omit<BaseFormField, "type"> {
+  type: "checkbox";
+  defaultValue?: boolean;
+}
+/**
+ * Radio group field.
+ */
+interface RadioFormField extends Omit<BaseFormField, "type"> {
+  type: "radio";
+  options: Array<{
+    label: string;
+    value: string;
+  }>;
+  defaultValue?: string;
+}
+/**
+ * File upload field.
+ */
+interface FileFormField extends Omit<BaseFormField, "type"> {
+  type: "file";
+  accept?: string;
+  multiple?: boolean;
+  maxFileSize?: number;
+  /**
+   * When true, files uploaded through this field are attached to all
+   * notification emails for this form. Default false.
+   */
+  attachToEmail?: boolean;
+}
+/**
+ * Date picker field.
+ */
+interface DateFormField extends Omit<BaseFormField, "type"> {
+  type: "date";
+  defaultValue?: string;
+  min?: string;
+  max?: string;
+}
+/**
+ * Time picker field.
+ */
+interface TimeFormField extends Omit<BaseFormField, "type"> {
+  type: "time";
+  defaultValue?: string;
+}
+/**
+ * Hidden field.
+ */
+interface HiddenFormField extends Omit<BaseFormField, "type"> {
+  type: "hidden";
+  defaultValue?: string;
+}
+interface ValidationRules {
+  /** Custom error message */
+  errorMessage?: string;
+  /** Custom validation function */
+  validate?: (value: unknown, formData: Record<string, unknown>) => boolean | string | Promise<boolean | string>;
+}
+/**
+ * Conditional logic configuration.
+ */
+interface ConditionalLogic {
+  /** Whether conditional logic is enabled */
+  enabled: boolean;
+  /** Action to perform when conditions are met */
+  action: "show" | "hide";
+  /** Logical operator for multiple conditions */
+  operator: "AND" | "OR";
+  /** Conditions to evaluate */
+  conditions: ConditionalLogicCondition[];
+}
+/**
+ * A single conditional logic condition.
+ */
+interface ConditionalLogicCondition {
+  /** Field name to check */
+  field: string;
+  /** Comparison operator */
+  comparison: "equals" | "notEquals" | "contains" | "isEmpty" | "isNotEmpty" | "greaterThan" | "lessThan";
+  /** Value to compare against (not used for isEmpty/isNotEmpty) */
+  value?: unknown;
+}
+/**
+ * Form settings and behavior.
+ */
+interface FormSettings {
+  /** Submit button text */
+  submitButtonText?: string;
+  /**
+   * Confirmation type after successful submission.
+   * - "message": Display a success message
+   * - "redirect": Redirect to a URL
+   * - "relationship": Redirect to a linked document (requires
+   *   `redirectRelationships` in the plugin options)
+   *
+   * @default "message"
+   */
+  confirmationType?: "message" | "redirect" | "relationship";
+  /**
+   * Linked document for relationship-based redirects (the collection's
+   * `redirectPage` relationship value). Preserved verbatim — resolution
+   * happens where the relationship is rendered.
+   */
+  redirectPage?: unknown;
+  /** Success message (supports HTML) - used when confirmationType is "message" */
+  successMessage?: string;
+  /** Redirect URL after successful submission - used when confirmationType is "redirect" */
+  redirectUrl?: string;
+  /**
+   * Relationship to redirect document - used when confirmationType is "redirect"
+   * and redirectRelationships are configured in plugin options.
+   */
+  redirectRelation?: {
+    relationTo: string;
+    value: string;
+  };
+  /** Allow multiple submissions from same IP (default true) */
+  allowMultipleSubmissions?: boolean;
+  /**
+   * Per-form honeypot override. Unset inherits the plugin's
+   * `spamProtection.honeypot`; the form wins where set.
+   */
+  honeypotEnabled?: boolean;
+  /**
+   * Per-form reCAPTCHA override. Unset inherits the plugin's
+   * `spamProtection.recaptcha.enabled`; the form wins where set.
+   */
+  captchaEnabled?: boolean;
+  /** reCAPTCHA site key (client-facing) when captcha is enabled per-form */
+  captchaSiteKey?: string;
+}
+/**
+ * Email notification configuration for a form.
+ */
+interface FormNotifications {
+  /** Enable email notifications */
+  enabled: boolean;
+  /** Recipient email addresses */
+  recipients: Array<{
+    email: string;
+    name?: string;
+  }>;
+  /** Email subject line */
+  subject?: string;
+  /** Use submitter's email as reply-to */
+  replyTo?: boolean;
+  /** Custom email template */
+  template?: string;
+}
+/**
+ * Form access control.
+ */
+interface FormAccess {
+  /** Who can submit the form */
+  submit?: (context: {
+    req: RequestContext;
+  }) => boolean | Promise<boolean>;
+  /** Who can view submissions */
+  read?: (context: {
+    req: RequestContext;
+  }) => boolean | Promise<boolean>;
+}
+/**
+ * Form lifecycle hooks.
+ */
+interface FormHooks {
+  /** Before submission validation */
+  beforeValidate?: Array<(context: FormHookContext) => void | Promise<void>>;
+  /** Before submission is saved */
+  beforeSubmit?: Array<(context: FormHookContext) => void | Promise<void>>;
+  /** After submission is saved */
+  afterSubmit?: Array<(context: FormHookContext) => void | Promise<void>>;
+}
+/**
+ * Hook context for form hooks.
+ */
+interface FormHookContext {
+  /** Form configuration */
+  form: FormConfig;
+  /** Submission data */
+  data: Record<string, unknown>;
+  /** Request context */
+  req: RequestContext;
+  /** Submission metadata */
+  metadata?: {
+    ipAddress?: string;
+    userAgent?: string;
+  };
+}
+/**
+ * Form submission data structure.
+ */
+interface FormSubmission {
+  /** Submission ID */
+  id: string;
+  /** Form slug */
+  formSlug: string;
+  /** Submission data (JSON) */
+  data: Record<string, unknown>;
+  /**
+   * Submission status.
+   *
+   * `spam` is one of them, not a separate flag: the stored field offers it, the
+   * admin has a Spam tab and filters its other views with `not_equals: "spam"`,
+   * and marking something "Not spam" moves it back to `new`.
+   */
+  status: "new" | "read" | "archived" | "spam";
+  /** Which spam check flagged this, when one did. */
+  spamReason?: string | null;
+  /** Internal notes (admin only) */
+  notes?: string;
+  /** Metadata */
+  ipAddress?: string;
+  userAgent?: string;
+  submittedAt: Date;
+  /** Created/updated timestamps */
+  createdAt: Date;
+  updatedAt: Date;
+}
+/**
+ * Resolved form builder configuration after applying defaults.
+ * Used internally by the plugin.
+ */
+interface ResolvedFormBuilderConfig {
+  formOverrides: ResolvedCollectionOverrides;
+  formSubmissionOverrides: ResolvedCollectionOverrides;
+  fields: FormFieldToggles;
+  /**
+   * The collection-to-URL map, with the array shorthand already expanded.
+   *
+   * ONE shape, so nothing downstream branches on which spelling was written.
+   * The list of redirect collections is `Object.keys` of this rather than a
+   * second field beside it, which would agree with it today and drift later.
+   */
+  redirectRelationships: RedirectRelationships;
+  /**
+   * Whether each redirect target collection is localized, keyed by slug.
+   *
+   * Resolved at `init` from the collection's own registered metadata rather
+   * than asked for in options, because the collection already declares it and
+   * a second declaration drifts.
+   *
+   * It decides whether a target's main-row `status` answers for the document:
+   * a localized collection publishes on a locale companion, so the row reads
+   * `draft` while a translation is public. A slug missing here is a collection
+   * whose metadata could not be read — undefined, not false, because reading
+   * an unknown as "not localized" is what marks a reachable translation as a
+   * draft.
+   */
+  redirectTargetLocalization: Record<string, boolean>;
+  beforeEmail?: FormBuilderPluginOptions["beforeEmail"];
+  notifications: {
+    defaultFrom?: string;
+    defaultToEmail?: string;
+    enabled: boolean;
+  };
+  spamProtection: {
+    honeypot: boolean;
+    recaptcha?: {
+      enabled: boolean;
+      siteKey?: string;
+      secretKey?: string;
+      scoreThreshold?: number;
+    };
+    rateLimit?: {
+      maxSubmissions: number;
+      windowMs: number;
+    };
+  };
+  uploads: {
+    maxFileSize: number;
+    allowedMimeTypes: string[];
+    uploadCollection: string;
+  };
+  features: {
+    builder: boolean;
+    conditionalLogic: boolean;
+    fileUploads: boolean;
+  };
+}
+/**
+ * Check if a value is a FormField.
+ */
+declare function isFormField(value: unknown): value is FormField;
+/**
+ * Check if a FormField is a specific type.
+ */
+declare function isFormFieldType<T extends FormField>(field: FormField, type: T["type"]): field is T;
+/**
+ * Type guard for text field.
+ */
+declare function isTextFormField(field: FormField): field is TextFormField;
+/**
+ * Type guard for email field.
+ */
+declare function isEmailFormField(field: FormField): field is EmailFormField;
+/**
+ * Type guard for select field.
+ */
+declare function isSelectFormField(field: FormField): field is SelectFormField;
+/**
+ * Type guard for checkbox field.
+ */
+declare function isCheckboxFormField(field: FormField): field is CheckboxFormField;
+/**
+ * Type guard for file field.
+ */
+declare function isFileFormField(field: FormField): field is FileFormField;
+export { RadioFormField as A, isEmailFormField as B, FormNotificationItem as C, HiddenFormField as D, FormSubmission as E, TextareaFormField as F, isSelectFormField as G, isFormField as H, TimeFormField as I, isTextFormField as K, UrlFormField as L, SelectFormField as M, SubmissionDocument as N, NumberFormField as O, TextFormField as P, ValidationRules as R, FormNotification as S, FormSettings as T, isFormFieldType as U, isFileFormField as V, isKnownFormField as W, FormField as _, ConditionalLogic as a, FormHookContext as b, DateFormField as c, FieldBlockConfig as d, FileFormField as f, FormDocument as g, FormConfig as h, CheckboxFormField as i, ResolvedFormBuilderConfig as j, PhoneFormField as k, EmailConfig as l, FormBuilderPluginOptions as m, BUILT_IN_FORM_FIELD_TYPES as n, ConditionalLogicCondition as o, FormAccess as p, BaseFormField as r, CustomFormField as s, AnyFormField as t, EmailFormField as u, FormFieldType as v, FormNotifications as w, FormHooks as x, FormFieldTypeId as y, isCheckboxFormField as z };
+//# sourceMappingURL=types-BHReIA0j.d.ts.map