@nextlyhq/plugin-form-builder 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,1663 @@
+import * as nextly from 'nextly';
+import { PluginDefinition, CollectionConfig, PluginContext } from 'nextly';
+import { R as ResolvedFormBuilderConfig, F as FormBuilderPluginOptions, a as FormConfig, b as FormSettings, c as FormNotifications, C as CheckboxFormField, D as DateFormField, E as EmailFormField, d as FileFormField, H as HiddenFormField, N as NumberFormField, P as PhoneFormField, e as RadioFormField, S as SelectFormField, T as TextFormField, f as TextareaFormField, g as TimeFormField, U as UrlFormField, h as ConditionalLogic, i as FormField, j as SubmissionDocument, k as FormDocument, W as WebhookEvent } from './index-C0kBvYjm.js';
+export { B as BaseFormField, l as ConditionalLogicCondition, m as EmailConfig, n as FieldBlockConfig, o as FormAccess, p as FormFieldType, q as FormHookContext, r as FormHooks, s as FormSubmission, t as SubmissionDetailProps, u as SubmissionListProps, V as ValidationRules, v as WebhookConfig, w as isCheckboxFormField, x as isEmailFormField, y as isFileFormField, z as isFormField, A as isFormFieldType, G as isSelectFormField, I as isTextFormField } from './index-C0kBvYjm.js';
+import { z } from 'zod';
+import 'react';
+
+/**
+ * Form Builder Plugin
+ *
+ * Visual form builder with drag-and-drop UI, submission management,
+ * email notifications, and spam protection.
+ *
+ * @module plugin
+ * @since 0.1.0
+ */
+
+type NextlyPlugin = PluginDefinition;
+interface FormBuilderPluginResult {
+    /** Plugin definition — pass to `defineConfig({ plugins: [...] })`. */
+    plugin: NextlyPlugin;
+    /** Forms & Submissions collections (also auto-added by the plugin). */
+    collections: CollectionConfig[];
+    /** Resolved configuration with all defaults applied. */
+    config: ResolvedFormBuilderConfig;
+}
+/**
+ * Create a Form Builder plugin instance.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { defineConfig } from "nextly/config";
+ * import { formBuilder } from "@nextlyhq/plugin-form-builder";
+ *
+ * const fb = formBuilder();
+ *
+ * export default defineConfig({
+ *   plugins: [fb.plugin],
+ * });
+ * ```
+ *
+ * @example With options
+ * ```ts
+ * const fb = formBuilder({
+ *   notifications: { defaultFrom: "noreply@example.com" },
+ *   spamProtection: { honeypot: true },
+ *   formOverrides: {
+ *     slug: "contact-forms",
+ *     labels: { singular: "Contact Form", plural: "Contact Forms" },
+ *   },
+ * });
+ * ```
+ */
+declare function formBuilder(options?: FormBuilderPluginOptions): FormBuilderPluginResult;
+/**
+ * Retrieve the resolved Form Builder config from a Nextly plugin context.
+ */
+declare function getFormBuilderConfig(nextly: unknown): ResolvedFormBuilderConfig | undefined;
+
+/**
+ * Form Configuration Validator
+ *
+ * Provides comprehensive validation for form configurations including:
+ * - Slug validation (format, reserved names)
+ * - Field name validation (format, duplicates)
+ * - Field-specific validation (select/radio options, min/max constraints)
+ * - Conditional logic validation
+ * - Nested field validation
+ *
+ * @module config/validate-form
+ * @since 1.0.0
+ *
+ * @example
+ * ```typescript
+ * import { validateFormConfig } from '@nextly/plugin-form-builder';
+ *
+ * const result = validateFormConfig(config);
+ * if (!result.valid) {
+ *   console.error('Validation errors:', result.errors);
+ * }
+ * ```
+ */
+
+/**
+ * Error codes for form validation failures.
+ * Used for programmatic error handling.
+ */
+type FormValidationErrorCode = "SLUG_REQUIRED" | "SLUG_INVALID_TYPE" | "SLUG_TOO_SHORT" | "SLUG_TOO_LONG" | "SLUG_INVALID_FORMAT" | "SLUG_RESERVED" | "FIELDS_REQUIRED" | "FIELDS_INVALID_TYPE" | "FIELDS_EMPTY" | "FIELD_NAME_REQUIRED" | "FIELD_NAME_INVALID_FORMAT" | "FIELD_NAME_DUPLICATE" | "FIELD_TYPE_REQUIRED" | "FIELD_TYPE_INVALID" | "FIELD_LABEL_REQUIRED" | "OPTIONS_REQUIRED" | "OPTIONS_EMPTY" | "MIN_GREATER_THAN_MAX" | "MIN_LENGTH_GREATER_THAN_MAX" | "FILE_MAX_SIZE_INVALID" | "CONDITIONS_REQUIRED" | "CONDITION_FIELD_REQUIRED" | "CONDITION_COMPARISON_REQUIRED" | "SETTINGS_INVALID_TYPE" | "REDIRECT_URL_REQUIRED" | "ACCESS_INVALID_TYPE" | "ACCESS_FUNCTION_INVALID";
+/**
+ * A single validation error with path and context.
+ *
+ * @example
+ * ```typescript
+ * const error: FormValidationError = {
+ *   path: 'fields.email.validation',
+ *   message: "Min length cannot be greater than max length",
+ *   code: 'MIN_LENGTH_GREATER_THAN_MAX',
+ * };
+ * ```
+ */
+interface FormValidationError {
+    /**
+     * Dot-notation path to the invalid property.
+     * @example 'slug', 'fields.0.name', 'fields.email.options'
+     */
+    path: string;
+    /**
+     * Human-readable error message.
+     */
+    message: string;
+    /**
+     * Machine-readable error code for programmatic handling.
+     */
+    code: FormValidationErrorCode;
+}
+/**
+ * Result of form config validation.
+ */
+interface FormValidationResult {
+    /**
+     * Whether the configuration is valid.
+     */
+    valid: boolean;
+    /**
+     * Array of validation errors (empty if valid).
+     */
+    errors: FormValidationError[];
+}
+/**
+ * Reserved form slugs that cannot be used.
+ * These are used by the system or have special meaning.
+ */
+declare const RESERVED_FORM_SLUGS: readonly ["api", "submit", "submissions", "export", "admin", "new", "create", "edit", "delete"];
+/**
+ * Validates a complete form configuration.
+ *
+ * This is the main entry point for form validation. It performs
+ * comprehensive validation including:
+ * - Slug format and reserved name checking
+ * - Field name validation
+ * - Field-specific validation (options, min/max, etc.)
+ * - Duplicate field name detection
+ * - Conditional logic validation
+ * - Settings validation
+ * - Access function type validation
+ *
+ * @param config - The form configuration to validate
+ * @returns Validation result with any errors found
+ *
+ * @example
+ * ```typescript
+ * import { validateFormConfig } from '@nextly/plugin-form-builder';
+ *
+ * const config = {
+ *   slug: 'contact-form',
+ *   fields: [
+ *     { type: 'text', name: 'firstName', label: 'First Name' },
+ *     { type: 'email', name: 'email', label: 'Email', required: true },
+ *   ],
+ * };
+ *
+ * const result = validateFormConfig(config);
+ *
+ * if (!result.valid) {
+ *   result.errors.forEach(err => {
+ *     console.error(`[${err.code}] ${err.path}: ${err.message}`);
+ *   });
+ * }
+ * ```
+ */
+declare function validateFormConfig(config: FormConfig): FormValidationResult;
+/**
+ * Throws an error if the form configuration is invalid.
+ *
+ * This is a convenience wrapper around `validateFormConfig` that
+ * throws a descriptive error instead of returning a result object.
+ *
+ * @param config - The form configuration to validate
+ * @throws Error if validation fails with all error messages
+ *
+ * @example
+ * ```typescript
+ * import { assertValidFormConfig } from '@nextly/plugin-form-builder';
+ *
+ * // Throws if invalid
+ * assertValidFormConfig(config);
+ * ```
+ */
+declare function assertValidFormConfig(config: FormConfig): void;
+
+/**
+ * Form Configuration Defaults
+ *
+ * Applies default values to form configurations, ensuring all required
+ * properties have sensible defaults while preserving user-specified values.
+ *
+ * @module config/defaults
+ * @since 1.0.0
+ *
+ * @example
+ * ```typescript
+ * import { applyFormDefaults } from '@nextly/plugin-form-builder';
+ *
+ * const config = {
+ *   slug: 'contact-form',
+ *   fields: [
+ *     { type: 'text', name: 'name', label: 'Name' },
+ *     { type: 'email', name: 'email', label: 'Email' },
+ *   ],
+ * };
+ *
+ * const configWithDefaults = applyFormDefaults(config);
+ * // configWithDefaults now has labels, settings, etc. with defaults applied
+ * ```
+ */
+
+/**
+ * Default form settings.
+ */
+declare const DEFAULT_FORM_SETTINGS: Required<Pick<FormSettings, "submitButtonText" | "confirmationType" | "successMessage" | "allowMultipleSubmissions">>;
+/**
+ * Default notification settings.
+ */
+declare const DEFAULT_NOTIFICATION_SETTINGS: Pick<FormNotifications, "enabled" | "replyTo">;
+/**
+ * Converts a slug to title case.
+ *
+ * @param str - The slug string to convert
+ * @returns Title case string
+ *
+ * @example
+ * ```typescript
+ * toTitleCase('contact-form'); // 'Contact Form'
+ * toTitleCase('newsletter_signup'); // 'Newsletter Signup'
+ * ```
+ */
+declare function toTitleCase(str: string): string;
+/**
+ * Generates a plural form from a singular label.
+ * Handles common English pluralization rules.
+ *
+ * @param singular - The singular form
+ * @returns The plural form
+ *
+ * @example
+ * ```typescript
+ * pluralize('Form'); // 'Forms'
+ * pluralize('Category'); // 'Categories'
+ * pluralize('Quiz'); // 'Quizzes'
+ * ```
+ */
+declare function pluralize(singular: string): string;
+/**
+ * Apply default values to form configuration.
+ *
+ * This function takes a partial form configuration and returns a complete
+ * configuration with all default values applied. User-specified values
+ * are preserved and take precedence over defaults.
+ *
+ * @param config - Form configuration (may be partial)
+ * @returns Configuration with defaults applied
+ *
+ * @example
+ * ```typescript
+ * import { applyFormDefaults } from '@nextly/plugin-form-builder';
+ *
+ * const config = {
+ *   slug: 'contact-form',
+ *   fields: [
+ *     { type: 'text', name: 'name', label: 'Name' },
+ *     { type: 'email', name: 'email', label: 'Email' },
+ *   ],
+ * };
+ *
+ * const result = applyFormDefaults(config);
+ *
+ * // Result:
+ * // {
+ * //   slug: 'contact-form',
+ * //   labels: { singular: 'Contact Form', plural: 'Contact Forms' },
+ * //   fields: [...],
+ * //   settings: {
+ * //     submitButtonText: 'Submit',
+ * //     confirmationType: 'message',
+ * //     successMessage: 'Thank you for your submission!',
+ * //     allowMultipleSubmissions: true,
+ * //   },
+ * //   access: {
+ * //     submit: () => true,
+ * //     read: ({ req }) => !!req.user,
+ * //   },
+ * // }
+ * ```
+ */
+declare function applyFormDefaults(config: FormConfig): FormConfig;
+/**
+ * Apply default values to individual form field.
+ *
+ * This is a utility function for applying defaults to a single field,
+ * useful when processing fields individually (e.g., in the Schema Builder).
+ *
+ * @param field - The field to apply defaults to
+ * @returns Field with defaults applied
+ *
+ * @example
+ * ```typescript
+ * import { applyFieldDefaults } from '@nextly/plugin-form-builder';
+ *
+ * const field = { type: 'text', name: 'firstName' };
+ * const fieldWithDefaults = applyFieldDefaults(field);
+ * // { type: 'text', name: 'firstName', label: 'First Name', required: false }
+ * ```
+ */
+declare function applyFieldDefaults<T extends {
+    type: string;
+    name?: string;
+    label?: string;
+    required?: boolean;
+}>(field: T): T;
+/**
+ * Creates a complete form config with minimal input.
+ *
+ * This is a convenience function for quickly creating form configs
+ * with sensible defaults. Only the slug and fields are required.
+ *
+ * @param slug - The form slug
+ * @param fields - Array of form fields
+ * @param options - Optional additional configuration
+ * @returns Complete form configuration
+ *
+ * @example
+ * ```typescript
+ * import { createFormConfig } from '@nextly/plugin-form-builder';
+ *
+ * const config = createFormConfig('contact', [
+ *   { type: 'text', name: 'name', label: 'Name', required: true },
+ *   { type: 'email', name: 'email', label: 'Email', required: true },
+ *   { type: 'textarea', name: 'message', label: 'Message' },
+ * ]);
+ * ```
+ */
+declare function createFormConfig(slug: string, fields: FormConfig["fields"], options?: Partial<Omit<FormConfig, "slug" | "fields">>): FormConfig;
+
+/**
+ * Form Field Helpers
+ *
+ * Convenient factory functions for creating form field configurations.
+ * These helpers eliminate the need to manually specify the `type` property,
+ * providing a cleaner, more ergonomic API for form definitions.
+ *
+ * @module config/field-helpers
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   text,
+ *   email,
+ *   select,
+ *   checkbox,
+ *   option,
+ * } from '@nextly/plugin-form-builder';
+ *
+ * const contactFormFields = [
+ *   text({ name: 'firstName', label: 'First Name', required: true }),
+ *   text({ name: 'lastName', label: 'Last Name', required: true }),
+ *   email({ name: 'email', label: 'Email Address', required: true }),
+ *   select({
+ *     name: 'subject',
+ *     label: 'Subject',
+ *     options: [
+ *       option('General Inquiry'),
+ *       option('Support Request'),
+ *       option('Feedback'),
+ *     ],
+ *   }),
+ *   checkbox({ name: 'subscribe', label: 'Subscribe to newsletter' }),
+ * ];
+ * ```
+ */
+
+/**
+ * Option for select and radio fields.
+ */
+interface FormFieldOption {
+    label: string;
+    value: string;
+}
+/**
+ * Creates an option for select or radio fields.
+ *
+ * If no value is provided, the label is converted to lowercase with
+ * spaces replaced by underscores.
+ *
+ * @param label - Display label for the option
+ * @param value - Optional value (defaults to lowercase label with underscores)
+ * @returns Option object with label and value
+ *
+ * @example
+ * ```typescript
+ * // Value derived from label
+ * option('United States') // { label: 'United States', value: 'united_states' }
+ *
+ * // Explicit value
+ * option('United States', 'us') // { label: 'United States', value: 'us' }
+ *
+ * // Usage in select field
+ * select({
+ *   name: 'country',
+ *   label: 'Country',
+ *   options: [
+ *     option('United States', 'us'),
+ *     option('Canada', 'ca'),
+ *     option('Mexico', 'mx'),
+ *   ],
+ * })
+ * ```
+ */
+declare const option: (label: string, value?: string) => FormFieldOption;
+/**
+ * Creates a text input field configuration.
+ *
+ * Text fields store simple string values with optional constraints
+ * like min/max length and pattern validation.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete text field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic text field
+ * text({ name: 'firstName', label: 'First Name', required: true })
+ *
+ * // Text with validation
+ * text({
+ *   name: 'username',
+ *   label: 'Username',
+ *   required: true,
+ *   placeholder: 'Enter username',
+ *   validation: {
+ *     minLength: 3,
+ *     maxLength: 20,
+ *     pattern: '^[a-zA-Z0-9_]+$',
+ *   },
+ * })
+ * ```
+ */
+declare const text: (config: Omit<TextFormField, "type">) => TextFormField;
+/**
+ * Creates an email input field configuration.
+ *
+ * Email fields provide built-in email format validation.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete email field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic email field
+ * email({ name: 'email', label: 'Email Address', required: true })
+ *
+ * // Email with placeholder
+ * email({
+ *   name: 'workEmail',
+ *   label: 'Work Email',
+ *   required: true,
+ *   placeholder: 'you@company.com',
+ * })
+ * ```
+ */
+declare const email: (config: Omit<EmailFormField, "type">) => EmailFormField;
+/**
+ * Creates a phone input field configuration.
+ *
+ * Phone fields are optimized for phone number entry with
+ * appropriate keyboard on mobile devices.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete phone field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic phone field
+ * phone({ name: 'phone', label: 'Phone Number', required: true })
+ *
+ * // Phone with placeholder
+ * phone({
+ *   name: 'mobile',
+ *   label: 'Mobile Number',
+ *   placeholder: '+1 (555) 123-4567',
+ * })
+ * ```
+ */
+declare const phone: (config: Omit<PhoneFormField, "type">) => PhoneFormField;
+/**
+ * Creates a URL input field configuration.
+ *
+ * URL fields provide built-in URL format validation.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete URL field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic URL field
+ * url({ name: 'website', label: 'Website URL' })
+ *
+ * // URL with placeholder
+ * url({
+ *   name: 'portfolio',
+ *   label: 'Portfolio URL',
+ *   placeholder: 'https://example.com',
+ * })
+ * ```
+ */
+declare const url: (config: Omit<UrlFormField, "type">) => UrlFormField;
+/**
+ * Creates a textarea field configuration.
+ *
+ * Textarea fields provide multi-line text input with configurable
+ * row count and length validation.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete textarea field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic textarea
+ * textarea({ name: 'message', label: 'Message', required: true })
+ *
+ * // Textarea with rows and validation
+ * textarea({
+ *   name: 'description',
+ *   label: 'Description',
+ *   rows: 5,
+ *   validation: {
+ *     minLength: 10,
+ *     maxLength: 500,
+ *   },
+ * })
+ * ```
+ */
+declare const textarea: (config: Omit<TextareaFormField, "type">) => TextareaFormField;
+/**
+ * Creates a number input field configuration.
+ *
+ * Number fields store numeric values with optional min/max/step
+ * constraints.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete number field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic number field
+ * number({ name: 'age', label: 'Age', required: true })
+ *
+ * // Number with range validation
+ * number({
+ *   name: 'quantity',
+ *   label: 'Quantity',
+ *   required: true,
+ *   validation: {
+ *     min: 1,
+ *     max: 100,
+ *     step: 1,
+ *   },
+ * })
+ * ```
+ */
+declare const number: (config: Omit<NumberFormField, "type">) => NumberFormField;
+/**
+ * Creates a select dropdown field configuration.
+ *
+ * Select fields display a dropdown list of options. Use the `option()`
+ * helper to create options.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete select field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic select
+ * select({
+ *   name: 'country',
+ *   label: 'Country',
+ *   required: true,
+ *   options: [
+ *     option('United States', 'us'),
+ *     option('Canada', 'ca'),
+ *     option('Mexico', 'mx'),
+ *   ],
+ * })
+ *
+ * // Multi-select
+ * select({
+ *   name: 'interests',
+ *   label: 'Interests',
+ *   allowMultiple: true,
+ *   options: [
+ *     option('Technology'),
+ *     option('Design'),
+ *     option('Business'),
+ *   ],
+ * })
+ * ```
+ */
+declare const select: (config: Omit<SelectFormField, "type">) => SelectFormField;
+/**
+ * Creates a single checkbox field configuration.
+ *
+ * Checkbox fields store boolean values (true/false).
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete checkbox field configuration
+ *
+ * @example
+ * ```typescript
+ * // Terms agreement checkbox
+ * checkbox({
+ *   name: 'agreeToTerms',
+ *   label: 'I agree to the terms and conditions',
+ *   required: true,
+ * })
+ *
+ * // Newsletter subscription
+ * checkbox({
+ *   name: 'subscribe',
+ *   label: 'Subscribe to our newsletter',
+ *   defaultValue: true,
+ * })
+ * ```
+ */
+declare const checkbox: (config: Omit<CheckboxFormField, "type">) => CheckboxFormField;
+/**
+ * Creates a radio group field configuration.
+ *
+ * Radio group fields allow selecting exactly one option from a list.
+ * Use the `option()` helper to create options.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete radio field configuration
+ *
+ * @example
+ * ```typescript
+ * radio({
+ *   name: 'contactMethod',
+ *   label: 'Preferred Contact Method',
+ *   required: true,
+ *   options: [
+ *     option('Email', 'email'),
+ *     option('Phone', 'phone'),
+ *     option('SMS', 'sms'),
+ *   ],
+ * })
+ * ```
+ */
+declare const radio: (config: Omit<RadioFormField, "type">) => RadioFormField;
+/**
+ * Creates a file upload field configuration.
+ *
+ * File fields allow users to upload files with configurable
+ * accepted types, size limits, and multiple file support.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete file field configuration
+ *
+ * @example
+ * ```typescript
+ * // Single file upload
+ * file({
+ *   name: 'resume',
+ *   label: 'Upload Resume',
+ *   required: true,
+ *   accept: 'application/pdf,.doc,.docx',
+ *   maxFileSize: 5242880, // 5MB
+ * })
+ *
+ * // Multiple images
+ * file({
+ *   name: 'photos',
+ *   label: 'Upload Photos',
+ *   accept: 'image/*',
+ *   multiple: true,
+ *   maxFileSize: 10485760, // 10MB
+ * })
+ * ```
+ */
+declare const file: (config: Omit<FileFormField, "type">) => FileFormField;
+/**
+ * Creates a date picker field configuration.
+ *
+ * Date fields provide a date picker with optional min/max constraints.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete date field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic date field
+ * date({ name: 'birthdate', label: 'Date of Birth', required: true })
+ *
+ * // Date with range constraints
+ * date({
+ *   name: 'eventDate',
+ *   label: 'Event Date',
+ *   required: true,
+ *   min: '2024-01-01',
+ *   max: '2024-12-31',
+ * })
+ * ```
+ */
+declare const date: (config: Omit<DateFormField, "type">) => DateFormField;
+/**
+ * Creates a time picker field configuration.
+ *
+ * Time fields provide a time picker for selecting time values.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete time field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic time field
+ * time({ name: 'appointmentTime', label: 'Preferred Time', required: true })
+ *
+ * // Time with default
+ * time({
+ *   name: 'meetingTime',
+ *   label: 'Meeting Time',
+ *   defaultValue: '09:00',
+ * })
+ * ```
+ */
+declare const time: (config: Omit<TimeFormField, "type">) => TimeFormField;
+/**
+ * Creates a hidden field configuration.
+ *
+ * Hidden fields store values that are not visible to users but
+ * are included in the submission data. Useful for tracking
+ * metadata like source, campaign, or referrer.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete hidden field configuration
+ *
+ * @example
+ * ```typescript
+ * // Track form source
+ * hidden({ name: 'source', label: 'Source', defaultValue: 'website' })
+ *
+ * // Campaign tracking
+ * hidden({ name: 'campaign', label: 'Campaign', defaultValue: 'summer-sale' })
+ * ```
+ */
+declare const hidden: (config: Omit<HiddenFormField, "type">) => HiddenFormField;
+
+/**
+ * Conditional Logic Evaluator
+ *
+ * Evaluates conditional logic rules to determine field visibility in forms.
+ * Used by the FormRenderer component to show/hide fields based on user input.
+ *
+ * @module utils/evaluate-conditions
+ * @since 1.0.0
+ *
+ * @example
+ * ```typescript
+ * import { evaluateConditions } from '@nextly/plugin-form-builder';
+ *
+ * const conditionalLogic = {
+ *   enabled: true,
+ *   action: 'show',
+ *   operator: 'AND',
+ *   conditions: [
+ *     { field: 'country', comparison: 'equals', value: 'US' },
+ *     { field: 'age', comparison: 'greaterThan', value: 18 },
+ *   ],
+ * };
+ *
+ * const formData = { country: 'US', age: 25 };
+ * const isVisible = evaluateConditions(conditionalLogic, formData);
+ * // isVisible = true (all conditions met, action is 'show')
+ * ```
+ */
+
+/**
+ * Comparison operators supported by the conditional logic system.
+ */
+type ComparisonOperator = "equals" | "notEquals" | "contains" | "isEmpty" | "isNotEmpty" | "greaterThan" | "lessThan";
+/**
+ * Evaluates conditional logic to determine field visibility.
+ *
+ * This is the main entry point for conditional logic evaluation.
+ * It evaluates all conditions according to the logical operator (AND/OR)
+ * and returns whether the field should be visible based on the action
+ * (show/hide).
+ *
+ * @param logic - The conditional logic configuration
+ * @param formData - The current form data (field values)
+ * @returns Whether the field should be visible
+ *
+ * @example
+ * ```typescript
+ * // Show field when country is US AND age is over 18
+ * const logic: ConditionalLogic = {
+ *   enabled: true,
+ *   action: 'show',
+ *   operator: 'AND',
+ *   conditions: [
+ *     { field: 'country', comparison: 'equals', value: 'US' },
+ *     { field: 'age', comparison: 'greaterThan', value: 18 },
+ *   ],
+ * };
+ *
+ * evaluateConditions(logic, { country: 'US', age: 25 }); // true
+ * evaluateConditions(logic, { country: 'US', age: 15 }); // false
+ * evaluateConditions(logic, { country: 'CA', age: 25 }); // false
+ *
+ * // Hide field when status is "completed"
+ * const hideLogic: ConditionalLogic = {
+ *   enabled: true,
+ *   action: 'hide',
+ *   operator: 'AND',
+ *   conditions: [
+ *     { field: 'status', comparison: 'equals', value: 'completed' },
+ *   ],
+ * };
+ *
+ * evaluateConditions(hideLogic, { status: 'completed' }); // false (hidden)
+ * evaluateConditions(hideLogic, { status: 'pending' });   // true (visible)
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Show field when either condition is met (OR)
+ * const orLogic: ConditionalLogic = {
+ *   enabled: true,
+ *   action: 'show',
+ *   operator: 'OR',
+ *   conditions: [
+ *     { field: 'role', comparison: 'equals', value: 'admin' },
+ *     { field: 'role', comparison: 'equals', value: 'editor' },
+ *   ],
+ * };
+ *
+ * evaluateConditions(orLogic, { role: 'admin' });  // true
+ * evaluateConditions(orLogic, { role: 'editor' }); // true
+ * evaluateConditions(orLogic, { role: 'viewer' }); // false
+ * ```
+ */
+declare function evaluateConditions(logic: ConditionalLogic | undefined, formData: Record<string, unknown>): boolean;
+/**
+ * Checks if a comparison operator is valid.
+ *
+ * @param operator - The operator to check
+ * @returns Whether the operator is valid
+ */
+declare function isValidComparisonOperator(operator: string): operator is ComparisonOperator;
+/**
+ * Gets the list of supported comparison operators.
+ *
+ * @returns Array of supported operator names
+ */
+declare function getSupportedComparisonOperators(): ComparisonOperator[];
+
+/**
+ * Dynamic Zod Schema Generator
+ *
+ * Converts FormField[] configuration to Zod validation schemas.
+ * Supports all form field types with proper validation rules.
+ *
+ * @module utils/generate-schema
+ * @since 0.1.0
+ */
+
+/**
+ * Generate a Zod validation schema from form field configuration.
+ *
+ * Creates a dynamic Zod schema based on the form fields array,
+ * applying appropriate validation rules for each field type.
+ *
+ * @param fields - Array of form field configurations
+ * @returns Zod object schema for validating submission data
+ *
+ * @example
+ * ```typescript
+ * const fields: FormField[] = [
+ *   { type: 'text', name: 'firstName', label: 'First Name', required: true },
+ *   { type: 'email', name: 'email', label: 'Email', required: true },
+ *   { type: 'number', name: 'age', label: 'Age', validation: { min: 18, max: 120 } },
+ * ];
+ *
+ * const schema = generateZodSchema(fields);
+ * const result = schema.safeParse({ firstName: 'John', email: 'john@example.com', age: 25 });
+ * ```
+ */
+declare function generateZodSchema(fields: FormField[]): z.ZodObject<Record<string, z.ZodTypeAny>>;
+/**
+ * Transform form data before validation.
+ *
+ * Handles type coercion and normalization:
+ * - Converts string numbers to actual numbers
+ * - Converts string booleans to actual booleans
+ * - Trims string values
+ * - Handles empty strings
+ *
+ * @param data - Raw form data
+ * @param fields - Form field configurations
+ * @returns Transformed data ready for validation
+ */
+declare function transformFormData(data: Record<string, unknown>, fields: FormField[]): Record<string, unknown>;
+/**
+ * Validate form data against a form's field configuration.
+ *
+ * Combines transformation and validation in one step.
+ *
+ * @param data - Raw form data
+ * @param fields - Form field configurations
+ * @returns Zod safe parse result
+ *
+ * @example
+ * ```typescript
+ * const result = validateFormData({ name: 'John', email: 'john@example.com' }, fields);
+ *
+ * if (result.success) {
+ *   console.log('Valid data:', result.data);
+ * } else {
+ *   console.log('Validation errors:', result.error.flatten());
+ * }
+ * ```
+ */
+declare function validateFormData(data: Record<string, unknown>, fields: FormField[]): z.SafeParseReturnType<Record<string, unknown>, Record<string, unknown>>;
+/**
+ * Get validation errors as a flat object.
+ *
+ * @param result - Zod safe parse result
+ * @returns Object mapping field names to error messages
+ */
+declare function getValidationErrors(result: z.SafeParseReturnType<unknown, unknown>): Record<string, string>;
+
+/**
+ * Export Formats Utilities
+ *
+ * Pure utility functions for exporting form submissions to CSV and JSON formats.
+ * These functions generate formatted strings that can be used for file downloads
+ * or API responses.
+ *
+ * @module utils/export-formats
+ * @since 0.1.0
+ */
+
+/**
+ * Options for CSV export.
+ */
+interface CSVExportOptions {
+    /**
+     * Whether to include metadata columns (_id, _status, _submittedAt, etc.).
+     * @default true
+     */
+    includeMetadata?: boolean;
+    /**
+     * Delimiter character for CSV.
+     * @default ","
+     */
+    delimiter?: string;
+    /**
+     * Whether to include UTF-8 BOM for Excel compatibility.
+     * @default true
+     */
+    includeBOM?: boolean;
+    /**
+     * Date format for timestamps.
+     * @default "iso" (ISO 8601)
+     */
+    dateFormat?: "iso" | "locale";
+}
+/**
+ * Options for JSON export.
+ */
+interface JSONExportOptions {
+    /**
+     * Whether to include metadata in each submission.
+     * @default true
+     */
+    includeMetadata?: boolean;
+    /**
+     * Whether to include form definition in the export.
+     * @default true
+     */
+    includeFormDefinition?: boolean;
+    /**
+     * Number of spaces for indentation (0 for minified).
+     * @default 2
+     */
+    indent?: number;
+}
+/**
+ * Exported JSON structure.
+ */
+interface ExportedJSON {
+    /** Export metadata */
+    exportedAt: string;
+    /** Form information (if includeFormDefinition is true) */
+    form?: {
+        id: string;
+        name: string;
+        slug: string;
+        fields: Array<{
+            name: string;
+            label: string;
+            type: string;
+        }>;
+    };
+    /** Total number of submissions in export */
+    totalSubmissions: number;
+    /** Array of submission data */
+    submissions: Array<Record<string, unknown>>;
+}
+/**
+ * Format a field value for export based on field type.
+ *
+ * @param value - The raw value from submission data
+ * @param field - The field definition (optional, for type-specific formatting)
+ * @returns Formatted string representation of the value
+ *
+ * @example
+ * ```typescript
+ * formatExportValue(true, { type: 'checkbox' }); // "Yes"
+ * formatExportValue(['a', 'b'], { type: 'select' }); // "a, b"
+ * formatExportValue(new Date(), { type: 'date' }); // "2024-01-15"
+ * ```
+ */
+declare function formatExportValue(value: unknown, field?: FormField): string;
+/**
+ * Export submissions to CSV format.
+ *
+ * Generates an RFC 4180 compliant CSV string with:
+ * - Form field values as columns (in form definition order)
+ * - Optional metadata columns at the end (_id, _status, _submittedAt, etc.)
+ * - Proper escaping of special characters
+ * - Optional UTF-8 BOM for Excel compatibility
+ *
+ * @param submissions - Array of submission documents to export
+ * @param form - Form document containing field definitions
+ * @param options - Export options
+ * @returns CSV formatted string
+ *
+ * @example
+ * ```typescript
+ * const csv = exportToCSV(submissions, form, {
+ *   includeMetadata: true,
+ *   includeBOM: true,
+ * });
+ *
+ * // Download in browser
+ * downloadFile(csv, 'submissions.csv', 'text/csv;charset=utf-8');
+ * ```
+ */
+declare function exportToCSV(submissions: SubmissionDocument[], form: FormDocument, options?: CSVExportOptions): string;
+/**
+ * Export submissions to JSON format.
+ *
+ * Generates a structured JSON export with:
+ * - Export metadata (timestamp)
+ * - Optional form definition
+ * - Array of submissions with field values
+ * - Optional submission metadata (_id, _status, etc.)
+ *
+ * @param submissions - Array of submission documents to export
+ * @param form - Form document containing field definitions
+ * @param options - Export options
+ * @returns JSON formatted string
+ *
+ * @example
+ * ```typescript
+ * const json = exportToJSON(submissions, form, {
+ *   includeMetadata: true,
+ *   includeFormDefinition: true,
+ *   indent: 2,
+ * });
+ *
+ * // Download in browser
+ * downloadFile(json, 'submissions.json', 'application/json');
+ * ```
+ */
+declare function exportToJSON(submissions: SubmissionDocument[], form: FormDocument, options?: JSONExportOptions): string;
+/**
+ * Trigger a file download in the browser.
+ *
+ * Creates a Blob from the content and triggers a download using a temporary
+ * anchor element. This function is browser-only and will throw in Node.js.
+ *
+ * @param content - File content as string
+ * @param filename - Name for the downloaded file
+ * @param mimeType - MIME type of the file
+ *
+ * @example
+ * ```typescript
+ * const csv = exportToCSV(submissions, form);
+ * downloadFile(csv, 'contact-form-submissions.csv', 'text/csv;charset=utf-8');
+ *
+ * const json = exportToJSON(submissions, form);
+ * downloadFile(json, 'submissions.json', 'application/json');
+ * ```
+ */
+declare function downloadFile(content: string, filename: string, mimeType: string): void;
+/**
+ * Generate a filename for export.
+ *
+ * Creates a filename with form slug and current timestamp.
+ *
+ * @param formSlug - The form's slug
+ * @param format - Export format ('csv' or 'json')
+ * @returns Generated filename
+ *
+ * @example
+ * ```typescript
+ * generateExportFilename('contact-form', 'csv');
+ * // Returns: "contact-form-submissions-2024-01-15.csv"
+ * ```
+ */
+declare function generateExportFilename(formSlug: string, format: "csv" | "json"): string;
+/**
+ * Export submissions and trigger browser download.
+ *
+ * Convenience function that combines export and download in one call.
+ * Browser-only.
+ *
+ * @param submissions - Array of submission documents
+ * @param form - Form document
+ * @param format - Export format ('csv' or 'json')
+ * @param options - Format-specific options
+ *
+ * @example
+ * ```typescript
+ * // In a React component
+ * const handleExport = (format: 'csv' | 'json') => {
+ *   exportAndDownload(submissions, form, format);
+ * };
+ * ```
+ */
+declare function exportAndDownload(submissions: SubmissionDocument[], form: FormDocument, format: "csv" | "json", options?: CSVExportOptions | JSONExportOptions): void;
+
+/**
+ * Form Submission Handler
+ *
+ * Processes form submissions including validation, spam detection,
+ * storage, and notification triggering.
+ *
+ * @module handlers/submit-form
+ * @since 0.1.0
+ */
+
+/**
+ * Options for submitting a form.
+ */
+interface SubmitFormOptions {
+    /** Form slug (URL-friendly identifier) */
+    formSlug: string;
+    /** Form submission data */
+    data: Record<string, unknown>;
+    /** Optional metadata about the submission */
+    metadata?: {
+        /** Submitter's IP address */
+        ipAddress?: string;
+        /** Submitter's user agent string */
+        userAgent?: string;
+    };
+}
+/**
+ * Result of form submission.
+ */
+interface SubmitFormResult {
+    /** Whether the submission was successful */
+    success: boolean;
+    /** The created submission document (on success) */
+    submission?: SubmissionDocument;
+    /** Error message (on failure) */
+    error?: string;
+    /** Field-level validation errors */
+    validationErrors?: Record<string, string>;
+    /** Redirect URL (if form configured for redirect on success) */
+    redirect?: string;
+}
+/**
+ * Context for the submission handler.
+ */
+interface SubmitFormContext {
+    /** Plugin context with access to services */
+    pluginContext: PluginContext;
+    /** Resolved plugin configuration */
+    pluginConfig: ResolvedFormBuilderConfig;
+}
+/**
+ * Process a form submission.
+ *
+ * This is the main entry point for handling form submissions.
+ * It performs the following steps:
+ *
+ * 1. Fetch form configuration by slug
+ * 2. Verify form status (must be "published")
+ * 3. Transform and validate submission data
+ * 4. Check for spam (honeypot, rate limiting)
+ * 5. Create submission record in database
+ * 6. Return result with redirect info if configured
+ *
+ * Note: Email notifications are triggered separately via collection
+ * hooks in the submissions collection (see Phase 4.2).
+ *
+ * @param options - Submission options
+ * @param context - Handler context with services
+ * @returns Submission result
+ *
+ * @example
+ * ```typescript
+ * const result = await submitForm(
+ *   {
+ *     formSlug: 'contact-form',
+ *     data: { name: 'John', email: 'john@example.com', message: 'Hello!' },
+ *     metadata: { ipAddress: '127.0.0.1', userAgent: 'Mozilla/5.0...' },
+ *   },
+ *   { pluginContext, pluginConfig }
+ * );
+ *
+ * if (result.success) {
+ *   console.log('Submission created:', result.submission?.id);
+ *   if (result.redirect) {
+ *     // Redirect user
+ *   }
+ * } else {
+ *   console.error('Submission failed:', result.error);
+ * }
+ * ```
+ */
+declare function submitForm(options: SubmitFormOptions, context: SubmitFormContext): Promise<SubmitFormResult>;
+/**
+ * Validate form data without creating a submission.
+ *
+ * Useful for real-time validation in the frontend.
+ *
+ * @param formSlug - Form slug
+ * @param data - Form data to validate
+ * @param context - Handler context
+ * @returns Validation result
+ *
+ * @example
+ * ```typescript
+ * const result = await validateSubmission(
+ *   'contact-form',
+ *   { name: 'John', email: 'invalid-email' },
+ *   { pluginContext, pluginConfig }
+ * );
+ *
+ * if (!result.valid) {
+ *   console.log('Validation errors:', result.errors);
+ * }
+ * ```
+ */
+declare function validateSubmission(formSlug: string, data: Record<string, unknown>, context: SubmitFormContext): Promise<{
+    valid: boolean;
+    errors?: Record<string, string>;
+}>;
+/**
+ * Check if a form is accepting submissions.
+ *
+ * @param formSlug - Form slug
+ * @param context - Handler context
+ * @returns Whether the form accepts submissions
+ */
+declare function isFormAcceptingSubmissions(formSlug: string, context: SubmitFormContext): Promise<boolean>;
+/**
+ * Get submission statistics for a form.
+ *
+ * Note: This function uses client-side filtering which works for
+ * small-medium submission counts. For large-scale deployments,
+ * consider using direct database queries with COUNT aggregation.
+ *
+ * @param formSlug - Form slug
+ * @param context - Handler context
+ * @returns Submission statistics
+ */
+declare function getFormSubmissionStats(formSlug: string, context: SubmitFormContext): Promise<{
+    total: number;
+    new: number;
+    read: number;
+    archived: number;
+} | null>;
+
+/**
+ * Spam Detection
+ *
+ * Implements honeypot and rate limiting spam protection for form submissions.
+ * Provides a pluggable approach to spam detection that can be extended.
+ *
+ * @module handlers/spam-detection
+ * @since 0.1.0
+ */
+/**
+ * Configuration for spam detection.
+ */
+interface SpamCheckConfig {
+    /**
+     * Enable honeypot field detection.
+     * When enabled, submissions with filled honeypot fields are marked as spam.
+     */
+    honeypot?: boolean;
+    /**
+     * Rate limiting configuration.
+     */
+    rateLimit?: {
+        /** Maximum submissions allowed per window */
+        maxSubmissions: number;
+        /** Time window in milliseconds */
+        windowMs: number;
+    };
+    /**
+     * reCAPTCHA configuration (for future implementation).
+     */
+    recaptcha?: {
+        enabled: boolean;
+        secretKey?: string;
+        scoreThreshold?: number;
+    };
+}
+/**
+ * Options for spam check.
+ */
+interface SpamCheckOptions {
+    /** Form submission data */
+    data: Record<string, unknown>;
+    /** Submitter's IP address */
+    ipAddress?: string;
+    /** Form slug for rate limiting key */
+    formSlug: string;
+    /** Spam protection configuration */
+    config: SpamCheckConfig;
+}
+/**
+ * Result of spam check.
+ */
+interface SpamCheckResult {
+    /** Whether the submission is detected as spam */
+    isSpam: boolean;
+    /** Reason for spam detection (for logging, not exposed to user) */
+    reason?: "honeypot" | "rate_limit" | "recaptcha";
+    /** Additional details (for logging) */
+    details?: string;
+}
+/**
+ * Check a form submission for spam indicators.
+ *
+ * Performs multiple spam checks based on configuration:
+ * 1. Honeypot field detection
+ * 2. Rate limiting by IP/form
+ * 3. reCAPTCHA verification (future)
+ *
+ * @param options - Spam check options
+ * @returns Spam check result
+ *
+ * @example
+ * ```typescript
+ * const result = await checkSpam({
+ *   data: formData,
+ *   ipAddress: req.ip,
+ *   formSlug: 'contact-form',
+ *   config: {
+ *     honeypot: true,
+ *     rateLimit: { maxSubmissions: 5, windowMs: 60000 },
+ *   },
+ * });
+ *
+ * if (result.isSpam) {
+ *   // Silently reject (return fake success to bot)
+ *   return { success: true };
+ * }
+ * ```
+ */
+declare function checkSpam(options: SpamCheckOptions): Promise<SpamCheckResult>;
+/**
+ * Clean up expired rate limit entries.
+ *
+ * Call this periodically (e.g., every 5 minutes) to prevent
+ * memory leaks from accumulated rate limit entries.
+ *
+ * @param maxAgeMs - Maximum age of entries to keep (default: 5 minutes)
+ * @returns Number of entries removed
+ *
+ * @example
+ * ```typescript
+ * // Set up periodic cleanup
+ * setInterval(() => {
+ *   const removed = cleanupRateLimitStore();
+ *   console.log(`Cleaned up ${removed} expired rate limit entries`);
+ * }, 5 * 60 * 1000); // Every 5 minutes
+ * ```
+ */
+declare function cleanupRateLimitStore(maxAgeMs?: number): number;
+/**
+ * Get the current size of the rate limit store.
+ *
+ * Useful for monitoring and debugging.
+ *
+ * @returns Number of entries in the store
+ */
+declare function getRateLimitStoreSize(): number;
+/**
+ * Clear all rate limit entries.
+ *
+ * Useful for testing or resetting state.
+ */
+declare function clearRateLimitStore(): void;
+/**
+ * Check if a specific IP/form is currently rate limited.
+ *
+ * @param ipAddress - IP address to check
+ * @param formSlug - Form slug
+ * @param config - Rate limit configuration
+ * @returns Whether the IP is currently rate limited
+ */
+declare function isRateLimited(ipAddress: string, formSlug: string, config: {
+    maxSubmissions: number;
+    windowMs: number;
+}): boolean;
+
+/**
+ * Webhook Handler
+ *
+ * Triggers webhook notifications for form events.
+ * Webhooks are fired asynchronously and do not block form submission.
+ *
+ * @module handlers/webhooks
+ * @since 0.1.0
+ */
+
+/**
+ * Webhook payload sent to configured endpoints.
+ */
+interface WebhookPayload {
+    /** Event type that triggered the webhook */
+    event: WebhookEvent;
+    /** ISO 8601 timestamp when the event occurred */
+    timestamp: string;
+    /** Form information */
+    form: {
+        id: string;
+        slug: string;
+        name: string;
+    };
+    /** Submission information (full data or minimal based on config) */
+    submission: SubmissionDocument | {
+        id: string;
+        submittedAt: Date;
+    };
+}
+/**
+ * Options for triggering webhooks.
+ */
+interface TriggerWebhooksOptions {
+    /** Event type */
+    event: WebhookEvent;
+    /** Form document */
+    form: FormDocument;
+    /** Submission document */
+    submission: SubmissionDocument;
+}
+/**
+ * Result of a single webhook delivery attempt.
+ */
+interface WebhookDeliveryResult {
+    /** Webhook URL */
+    url: string;
+    /** Whether the delivery was successful */
+    success: boolean;
+    /** HTTP status code (if request completed) */
+    statusCode?: number;
+    /** Error message (if delivery failed) */
+    error?: string;
+    /** Time taken in milliseconds */
+    durationMs: number;
+}
+/**
+ * Result of triggering webhooks for an event.
+ */
+interface TriggerWebhooksResult {
+    /** Number of webhooks triggered */
+    triggered: number;
+    /** Number of successful deliveries */
+    successful: number;
+    /** Number of failed deliveries */
+    failed: number;
+    /** Individual delivery results */
+    results: WebhookDeliveryResult[];
+}
+/**
+ * Trigger webhooks for a form event.
+ *
+ * This function fires all matching webhooks asynchronously and does not
+ * block form submission. Failed webhooks are logged but do not cause
+ * submission failures.
+ *
+ * @param options - Trigger options
+ * @returns Result of webhook triggering
+ *
+ * @example
+ * ```typescript
+ * // After creating a submission
+ * const result = await triggerWebhooks({
+ *   event: 'submission.created',
+ *   form,
+ *   submission,
+ * });
+ *
+ * console.log(`Triggered ${result.triggered} webhooks`);
+ * console.log(`Successful: ${result.successful}, Failed: ${result.failed}`);
+ * ```
+ */
+declare function triggerWebhooks(options: TriggerWebhooksOptions): Promise<TriggerWebhooksResult>;
+/**
+ * Trigger webhooks without waiting for completion.
+ *
+ * This is the recommended way to call webhooks from submission handlers
+ * as it doesn't block the response. Errors are logged but not thrown.
+ *
+ * @param options - Trigger options
+ * @param logger - Optional logger for error reporting
+ *
+ * @example
+ * ```typescript
+ * // In submission handler - fire and forget
+ * fireWebhooks(
+ *   { event: 'submission.created', form, submission },
+ *   pluginContext.infra.logger
+ * );
+ *
+ * // Continue with response immediately
+ * return { success: true, submission };
+ * ```
+ */
+declare function fireWebhooks(options: TriggerWebhooksOptions, logger?: {
+    info?: (message: string, data?: Record<string, unknown>) => void;
+    warn?: (message: string, data?: Record<string, unknown>) => void;
+    error?: (message: string, data?: Record<string, unknown>) => void;
+}): void;
+/**
+ * Validate a webhook URL.
+ *
+ * @param url - URL to validate
+ * @returns Whether the URL is valid for webhooks
+ */
+declare function isValidWebhookUrl(url: string): boolean;
+/**
+ * Get the list of supported webhook events.
+ *
+ * @returns Array of supported event types
+ */
+declare function getSupportedWebhookEvents(): WebhookEvent[];
+
+/**
+ * Forms Collection
+ *
+ * Stores form definitions created via Code-First or Schema Builder.
+ * Each form contains field definitions, settings, notifications, and access control.
+ *
+ * @module collections/forms
+ * @since 0.1.0
+ */
+
+/**
+ * Component path string format.
+ * Format: `"package-name/path#ExportName"`
+ */
+type ComponentPath = string;
+/**
+ * Custom view configuration for replacing default admin views.
+ */
+interface CollectionAdminViewConfig {
+    /** Component path to the custom view component */
+    Component: ComponentPath;
+}
+/**
+ * Custom components configuration for collection admin UI.
+ */
+interface CollectionAdminComponents {
+    views?: {
+        Edit?: CollectionAdminViewConfig;
+        List?: CollectionAdminViewConfig;
+    };
+    BeforeListTable?: ComponentPath;
+    AfterListTable?: ComponentPath;
+    BeforeEdit?: ComponentPath;
+    AfterEdit?: ComponentPath;
+}
+/**
+ * Extended CollectionConfig with custom admin components support.
+ * This extends the base CollectionConfig to include the components property.
+ */
+interface ExtendedCollectionConfig$1 extends Omit<CollectionConfig, "admin"> {
+    admin?: CollectionConfig["admin"] & {
+        /** Whether this collection is provided by a plugin */
+        isPlugin?: boolean;
+        components?: CollectionAdminComponents;
+    };
+}
+/**
+ * Generate the Forms collection configuration.
+ *
+ * Creates a collection for storing form definitions with fields,
+ * settings, notifications, and access control.
+ *
+ * @param pluginConfig - Resolved plugin configuration
+ * @returns ExtendedCollectionConfig for the Forms collection (with custom admin components)
+ *
+ * @example
+ * ```typescript
+ * const formsCol = formsCollection(resolvedConfig);
+ * // Returns a collection with slug "forms" (or custom slug from config)
+ * ```
+ */
+declare function formsCollection(pluginConfig: ResolvedFormBuilderConfig): ExtendedCollectionConfig$1;
+
+/**
+ * Form Submissions Collection
+ *
+ * Stores form submission data from user-submitted forms.
+ * Each submission contains the submitted data, metadata, and status.
+ *
+ * @module collections/submissions
+ * @since 0.1.0
+ */
+
+/**
+ * Extended CollectionConfig with isPlugin support.
+ * This extends the base CollectionConfig to include the isPlugin property.
+ */
+interface ExtendedCollectionConfig extends Omit<CollectionConfig, "admin"> {
+    admin?: CollectionConfig["admin"] & {
+        /** Whether this collection is provided by a plugin */
+        isPlugin?: boolean;
+    };
+}
+/**
+ * Generate the Form Submissions collection configuration.
+ *
+ * Creates a collection for storing form submissions with:
+ * - Reference to the parent form
+ * - Submitted data (JSON)
+ * - Status tracking (new, read, archived)
+ * - Metadata (IP, user agent, timestamp)
+ * - Internal notes for admin use
+ *
+ * @param pluginConfig - Resolved plugin configuration
+ * @returns CollectionConfig for the Submissions collection
+ *
+ * @example
+ * ```typescript
+ * const submissionsCol = submissionsCollection(resolvedConfig);
+ * // Returns a collection with slug "form-submissions" (or custom slug from config)
+ * ```
+ */
+declare function submissionsCollection(pluginConfig: ResolvedFormBuilderConfig): ExtendedCollectionConfig;
+
+declare const formBuilderPlugin: nextly.PluginDefinition;
+
+export { type CSVExportOptions, CheckboxFormField, type ComparisonOperator, ConditionalLogic, DEFAULT_FORM_SETTINGS, DEFAULT_NOTIFICATION_SETTINGS, DateFormField, EmailFormField, type ExportedJSON, FileFormField, FormBuilderPluginOptions, type FormBuilderPluginResult, FormConfig, FormDocument, FormField, type FormFieldOption, FormNotifications, FormSettings, type FormValidationError, type FormValidationErrorCode, type FormValidationResult, HiddenFormField, type JSONExportOptions, type NextlyPlugin, NumberFormField, PhoneFormField, RESERVED_FORM_SLUGS, RadioFormField, ResolvedFormBuilderConfig, SelectFormField, type SpamCheckConfig, type SpamCheckOptions, type SpamCheckResult, SubmissionDocument, type SubmitFormContext, type SubmitFormOptions, type SubmitFormResult, TextFormField, TextareaFormField, TimeFormField, type TriggerWebhooksOptions, type TriggerWebhooksResult, UrlFormField, type WebhookDeliveryResult, WebhookEvent, type WebhookPayload, applyFieldDefaults, applyFormDefaults, assertValidFormConfig, checkSpam, checkbox, cleanupRateLimitStore, clearRateLimitStore, createFormConfig, date, downloadFile, email, evaluateConditions, exportAndDownload, exportToCSV, exportToJSON, file, fireWebhooks, formBuilder, formBuilderPlugin, formatExportValue, formsCollection, generateExportFilename, generateZodSchema, getFormBuilderConfig, getFormSubmissionStats, getRateLimitStoreSize, getSupportedComparisonOperators, getSupportedWebhookEvents, getValidationErrors, hidden, isFormAcceptingSubmissions, isRateLimited, isValidComparisonOperator, isValidWebhookUrl, number, option, phone, pluralize, radio, select, submissionsCollection, submitForm, text, textarea, time, toTitleCase, transformFormData, triggerWebhooks, url, validateFormConfig, validateFormData, validateSubmission };