nextly 0.0.1 → 0.0.2-alpha.1

package/dist/_dts-chunks/define-component.d-BUgTHmt3.d.ts

@@ -0,0 +1,1149 @@
+import { P as FieldConfig, ay as RepeaterFieldConfig, X as GroupFieldConfig, c as CheckboxFieldConfig, f as ChipsFieldConfig, j as CodeFieldConfig, u as ComponentFieldConfig, x as DataFieldConfig, E as DateFieldConfig, J as EmailFieldConfig, a3 as JSONFieldConfig, ac as NumberFieldConfig, ag as PasswordFieldConfig, aj as RadioFieldConfig, ao as RelationshipFieldConfig, a$ as UploadFieldConfig, aG as RichTextFieldConfig, aL as SelectFieldConfig, aV as TextFieldConfig, aY as TextareaFieldConfig, aN as SelectOption, aQ as SingleConfig, t as ComponentConfig } from './collections-handler.d-DjgO74Wt.d.ts';
+import { N as NextlyConfig, S as SanitizedNextlyConfig } from './config.d-DNwsDnjs.d.ts';
+
+/**
+ * Field Type Guards
+ *
+ * Runtime type guard functions for narrowing FieldConfig union types.
+ * Uses discriminated union pattern based on the `type` property.
+ *
+ * @module collections/fields/guards
+ * @since 1.0.0
+ */
+
+/**
+ * Type guard for text field config.
+ *
+ * @example
+ * ```typescript
+ * if (isTextField(field)) {
+ *   console.log(field.hasMany, field.minLength, field.maxLength);
+ * }
+ * ```
+ */
+declare const isTextField: (field: FieldConfig) => field is TextFieldConfig;
+/**
+ * Type guard for textarea field config.
+ *
+ * @example
+ * ```typescript
+ * if (isTextareaField(field)) {
+ *   console.log(field.rows);
+ * }
+ * ```
+ */
+declare const isTextareaField: (field: FieldConfig) => field is TextareaFieldConfig;
+/**
+ * Type guard for rich text field config.
+ *
+ * @example
+ * ```typescript
+ * if (isRichTextField(field)) {
+ *   console.log(field.features);
+ * }
+ * ```
+ */
+declare const isRichTextField: (field: FieldConfig) => field is RichTextFieldConfig;
+/**
+ * Type guard for email field config.
+ *
+ * @example
+ * ```typescript
+ * if (isEmailField(field)) {
+ *   // Email field has auto-validation
+ * }
+ * ```
+ */
+declare const isEmailField: (field: FieldConfig) => field is EmailFieldConfig;
+/**
+ * Type guard for password field config.
+ *
+ * @example
+ * ```typescript
+ * if (isPasswordField(field)) {
+ *   console.log(field.minLength, field.maxLength);
+ * }
+ * ```
+ */
+declare const isPasswordField: (field: FieldConfig) => field is PasswordFieldConfig;
+/**
+ * Type guard for code field config.
+ *
+ * @example
+ * ```typescript
+ * if (isCodeField(field)) {
+ *   console.log(field.language, field.editorOptions);
+ * }
+ * ```
+ */
+declare const isCodeField: (field: FieldConfig) => field is CodeFieldConfig;
+/**
+ * Type guard for number field config.
+ *
+ * @example
+ * ```typescript
+ * if (isNumberField(field)) {
+ *   console.log(field.min, field.max, field.step);
+ * }
+ * ```
+ */
+declare const isNumberField: (field: FieldConfig) => field is NumberFieldConfig;
+/**
+ * Type guard for checkbox field config.
+ *
+ * @example
+ * ```typescript
+ * if (isCheckboxField(field)) {
+ *   console.log(field.defaultValue); // boolean
+ * }
+ * ```
+ */
+declare const isCheckboxField: (field: FieldConfig) => field is CheckboxFieldConfig;
+/**
+ * Type guard for date field config.
+ *
+ * @example
+ * ```typescript
+ * if (isDateField(field)) {
+ *   console.log(field.admin?.date?.pickerAppearance);
+ * }
+ * ```
+ */
+declare const isDateField: (field: FieldConfig) => field is DateFieldConfig;
+/**
+ * Type guard for select field config.
+ *
+ * @example
+ * ```typescript
+ * if (isSelectField(field)) {
+ *   console.log(field.options, field.hasMany);
+ * }
+ * ```
+ */
+declare const isSelectField: (field: FieldConfig) => field is SelectFieldConfig;
+/**
+ * Type guard for radio field config.
+ *
+ * @example
+ * ```typescript
+ * if (isRadioField(field)) {
+ *   console.log(field.options, field.admin?.layout);
+ * }
+ * ```
+ */
+declare const isRadioField: (field: FieldConfig) => field is RadioFieldConfig;
+/**
+ * Type guard for upload field config.
+ *
+ * @example
+ * ```typescript
+ * if (isUploadField(field)) {
+ *   console.log(field.relationTo, field.hasMany);
+ * }
+ * ```
+ */
+declare const isUploadField: (field: FieldConfig) => field is UploadFieldConfig;
+/**
+ * Type guard for relationship field config.
+ *
+ * @example
+ * ```typescript
+ * if (isRelationshipField(field)) {
+ *   console.log(field.relationTo, field.hasMany, field.maxDepth);
+ * }
+ * ```
+ */
+declare const isRelationshipField: (field: FieldConfig) => field is RelationshipFieldConfig;
+/**
+ * Type guard for repeater field config.
+ *
+ * @example
+ * ```typescript
+ * if (isRepeaterField(field)) {
+ *   console.log(field.fields, field.minRows, field.maxRows);
+ * }
+ * ```
+ */
+declare function isRepeaterField(field: FieldConfig): field is RepeaterFieldConfig;
+/**
+ * Type guard for group field config.
+ *
+ * @example
+ * ```typescript
+ * if (isGroupField(field)) {
+ *   console.log(field.fields, field.admin?.hideGutter);
+ * }
+ * ```
+ */
+declare const isGroupField: (field: FieldConfig) => field is GroupFieldConfig;
+/**
+ * Type guard for JSON field config.
+ *
+ * @example
+ * ```typescript
+ * if (isJSONField(field)) {
+ *   console.log(field.jsonSchema, field.editorOptions);
+ * }
+ * ```
+ */
+declare const isJSONField: (field: FieldConfig) => field is JSONFieldConfig;
+/**
+ * Type guard for component field config.
+ *
+ * @example
+ * ```typescript
+ * if (isComponentField(field)) {
+ *   console.log(field.component, field.components, field.repeatable);
+ * }
+ * ```
+ */
+declare const isComponentField: (field: FieldConfig) => field is ComponentFieldConfig;
+/**
+ * Type guard for chips field config.
+ *
+ * @example
+ * ```typescript
+ * if (isChipsField(field)) {
+ *   console.log(field.maxChips, field.minChips);
+ * }
+ * ```
+ */
+declare const isChipsField: (field: FieldConfig) => field is ChipsFieldConfig;
+/**
+ * Type guard for data-storing fields.
+ *
+ * Returns true if the field stores data in the database.
+ *
+ * @example
+ * ```typescript
+ * if (isDataField(field)) {
+ *   // Generate database column for this field
+ *   generateColumn(field);
+ * }
+ * ```
+ */
+declare function isDataField(field: FieldConfig): field is DataFieldConfig;
+/**
+ * Type guard for fields that contain nested fields.
+ *
+ * Returns true for array and group fields.
+ * These field types have a `fields` property containing
+ * nested field configurations.
+ *
+ * @example
+ * ```typescript
+ * if (hasNestedFields(field)) {
+ *   // Recursively process nested fields
+ *   const nestedFields = 'fields' in field ? field.fields : [];
+ *   nestedFields.forEach(processField);
+ * }
+ * ```
+ */
+declare function hasNestedFields(field: FieldConfig): field is RepeaterFieldConfig | GroupFieldConfig;
+/**
+ * Type guard for relational fields.
+ *
+ * Returns true for relationship and upload fields.
+ * These field types reference other collections via `relationTo`.
+ *
+ * @example
+ * ```typescript
+ * if (isRelationalField(field)) {
+ *   console.log(field.relationTo, field.hasMany, field.maxDepth);
+ * }
+ * ```
+ */
+declare function isRelationalField(field: FieldConfig): field is RelationshipFieldConfig | UploadFieldConfig;
+
+/**
+ * Field Builder Helpers
+ *
+ * Convenient factory functions for creating field configurations.
+ * These helpers eliminate the need to manually specify the `type` property,
+ * providing a cleaner, more ergonomic API for code-first collection definitions.
+ *
+ * @module collections/fields/helpers
+ * @since 1.0.0
+ *
+ * @example
+ * ```typescript
+ * import { text, select, relationship, option } from '@nextly/collections/fields';
+ *
+ * const fields = [
+ *   text({ name: 'title', required: true }),
+ *   select({
+ *     name: 'status',
+ *     options: [
+ *       option('Draft'),
+ *       option('Published'),
+ *       option('Archived'),
+ *     ],
+ *   }),
+ *   relationship({ name: 'author', relationTo: 'users' }),
+ * ];
+ * ```
+ */
+
+/**
+ * Creates a text field configuration.
+ *
+ * Text fields store simple string values with optional constraints
+ * like min/max length. Supports `hasMany` for storing arrays of strings.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete text field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic text field
+ * text({ name: 'title', required: true })
+ *
+ * // Text with constraints
+ * text({ name: 'slug', minLength: 3, maxLength: 100, unique: true })
+ *
+ * // Multiple values (tags)
+ * text({ name: 'tags', hasMany: true, minRows: 1, maxRows: 10 })
+ * ```
+ */
+declare const text: (config: Omit<TextFieldConfig, "type">) => TextFieldConfig;
+/**
+ * Creates a textarea field configuration.
+ *
+ * Textarea fields store longer text content with a multi-line input.
+ * Supports configurable row height and resize behavior.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete textarea field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic textarea
+ * textarea({ name: 'description' })
+ *
+ * // Fixed height textarea
+ * textarea({ name: 'bio', admin: { rows: 5, resize: 'none' } })
+ * ```
+ */
+declare const textarea: (config: Omit<TextareaFieldConfig, "type">) => TextareaFieldConfig;
+/**
+ * Creates a rich text field configuration.
+ *
+ * Rich text fields provide a Lexical-based WYSIWYG editor with
+ * configurable formatting features (bold, italic, lists, etc.).
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete rich text field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic rich text
+ * richText({ name: 'content' })
+ *
+ * // Rich text with specific features
+ * richText({
+ *   name: 'body',
+ *   features: ['bold', 'italic', 'link', 'orderedList', 'unorderedList'],
+ * })
+ * ```
+ */
+declare const richText: (config: Omit<RichTextFieldConfig, "type">) => RichTextFieldConfig;
+/**
+ * Creates an email field configuration.
+ *
+ * Email fields store email addresses with built-in format validation.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete email field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic email field
+ * email({ name: 'email', required: true, unique: true })
+ *
+ * // Optional contact email
+ * email({ name: 'contactEmail', label: 'Contact Email' })
+ * ```
+ */
+declare const email: (config: Omit<EmailFieldConfig, "type">) => EmailFieldConfig;
+/**
+ * Creates a password field configuration.
+ *
+ * Password fields store hashed passwords with masked input.
+ * Includes optional strength indicator and auto-generation.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete password field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic password field
+ * password({ name: 'password', required: true })
+ *
+ * // Password with strength indicator
+ * password({
+ *   name: 'password',
+ *   minLength: 8,
+ *   admin: { showStrengthIndicator: true },
+ * })
+ * ```
+ */
+declare const password: (config: Omit<PasswordFieldConfig, "type">) => PasswordFieldConfig;
+/**
+ * Creates a code field configuration.
+ *
+ * Code fields provide a code editor with syntax highlighting
+ * for various programming languages.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete code field configuration
+ *
+ * @example
+ * ```typescript
+ * // JavaScript code field
+ * code({ name: 'snippet', language: 'javascript' })
+ *
+ * // JSON configuration field
+ * code({
+ *   name: 'config',
+ *   language: 'json',
+ *   admin: { editorOptions: { lineNumbers: true } },
+ * })
+ * ```
+ */
+declare const code: (config: Omit<CodeFieldConfig, "type">) => CodeFieldConfig;
+/**
+ * Creates a number field configuration.
+ *
+ * Number fields store numeric values (integers or decimals)
+ * with optional min/max constraints and step values.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete number field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic number field
+ * number({ name: 'price', required: true })
+ *
+ * // Integer with range
+ * number({ name: 'quantity', min: 0, max: 100, step: 1 })
+ *
+ * // Decimal price
+ * number({ name: 'amount', min: 0, step: 0.01 })
+ * ```
+ */
+declare const number: (config: Omit<NumberFieldConfig, "type">) => NumberFieldConfig;
+/**
+ * Creates a checkbox field configuration.
+ *
+ * Checkbox fields store boolean true/false values.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete checkbox field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic checkbox
+ * checkbox({ name: 'isActive', defaultValue: true })
+ *
+ * // Feature flag
+ * checkbox({ name: 'featured', label: 'Featured Post' })
+ * ```
+ */
+declare const checkbox: (config: Omit<CheckboxFieldConfig, "type">) => CheckboxFieldConfig;
+/**
+ * Creates a date field configuration.
+ *
+ * Date fields store date and/or time values with a date picker UI.
+ * Supports various display formats and picker appearances.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete date field configuration
+ *
+ * @example
+ * ```typescript
+ * // Date only
+ * date({ name: 'publishedAt' })
+ *
+ * // Date and time
+ * date({
+ *   name: 'eventTime',
+ *   admin: { date: { pickerAppearance: 'dayAndTime' } },
+ * })
+ *
+ * // Time only
+ * date({
+ *   name: 'openingTime',
+ *   admin: { date: { pickerAppearance: 'timeOnly' } },
+ * })
+ * ```
+ */
+declare const date: (config: Omit<DateFieldConfig, "type">) => DateFieldConfig;
+/**
+ * Creates a select field configuration.
+ *
+ * Select fields provide a dropdown for choosing from predefined options.
+ * Supports single or multiple selections with searchable dropdown.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete select field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic select
+ * select({
+ *   name: 'status',
+ *   options: [
+ *     { label: 'Draft', value: 'draft' },
+ *     { label: 'Published', value: 'published' },
+ *   ],
+ * })
+ *
+ * // Using option helper
+ * select({
+ *   name: 'status',
+ *   options: [option('Draft'), option('Published'), option('Archived')],
+ * })
+ *
+ * // Multi-select
+ * select({
+ *   name: 'categories',
+ *   hasMany: true,
+ *   options: [option('Tech'), option('Business'), option('Design')],
+ * })
+ * ```
+ */
+declare const select: (config: Omit<SelectFieldConfig, "type">) => SelectFieldConfig;
+/**
+ * Creates a radio field configuration.
+ *
+ * Radio fields display options as radio buttons for single selection.
+ * Better for small option sets where all choices should be visible.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete radio field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic radio field
+ * radio({
+ *   name: 'priority',
+ *   options: [option('Low'), option('Medium'), option('High')],
+ * })
+ *
+ * // Horizontal layout
+ * radio({
+ *   name: 'size',
+ *   options: [option('S'), option('M'), option('L'), option('XL')],
+ *   admin: { layout: 'horizontal' },
+ * })
+ * ```
+ */
+declare const radio: (config: Omit<RadioFieldConfig, "type">) => RadioFieldConfig;
+/**
+ * Creates an upload field configuration.
+ *
+ * Upload fields reference files from upload-enabled collections.
+ * Supports single or multiple files with polymorphic references.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete upload field configuration
+ *
+ * @example
+ * ```typescript
+ * // Single image
+ * upload({ name: 'featuredImage', relationTo: 'media' })
+ *
+ * // Multiple images (gallery)
+ * upload({
+ *   name: 'gallery',
+ *   relationTo: 'media',
+ *   hasMany: true,
+ *   maxRows: 10,
+ * })
+ *
+ * // Polymorphic uploads (multiple collections)
+ * upload({
+ *   name: 'attachment',
+ *   relationTo: ['media', 'documents'],
+ * })
+ * ```
+ */
+declare const upload: (config: Omit<UploadFieldConfig, "type">) => UploadFieldConfig;
+/**
+ * Creates a relationship field configuration.
+ *
+ * Relationship fields reference documents from other collections.
+ * Supports single or multiple references with polymorphic relations.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete relationship field configuration
+ *
+ * @example
+ * ```typescript
+ * // Single relationship
+ * relationship({ name: 'author', relationTo: 'users' })
+ *
+ * // Multiple relationships
+ * relationship({
+ *   name: 'relatedPosts',
+ *   relationTo: 'posts',
+ *   hasMany: true,
+ *   maxRows: 5,
+ * })
+ *
+ * // Polymorphic relationship
+ * relationship({
+ *   name: 'reference',
+ *   relationTo: ['posts', 'pages', 'products'],
+ * })
+ * ```
+ */
+declare const relationship: (config: Omit<RelationshipFieldConfig, "type">) => RelationshipFieldConfig;
+/**
+ * Creates an array field configuration.
+ *
+ * Array fields store repeatable sets of fields. Each row in the
+ * array has the same structure defined by the `fields` property.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete array field configuration
+ *
+ * @example
+ * ```typescript
+ * // Simple array of links
+ * array({
+ *   name: 'links',
+ *   fields: [
+ *     text({ name: 'label', required: true }),
+ *     text({ name: 'url', required: true }),
+ *   ],
+ * })
+ *
+ * // Array with constraints
+ * array({
+ *   name: 'features',
+ *   minRows: 1,
+ *   maxRows: 10,
+ *   fields: [
+ *     text({ name: 'title', required: true }),
+ *     textarea({ name: 'description' }),
+ *     upload({ name: 'icon', relationTo: 'media' }),
+ *   ],
+ * })
+ * ```
+ */
+declare const array: (config: Omit<RepeaterFieldConfig, "type">) => RepeaterFieldConfig;
+/**
+ * Creates a repeater field configuration.
+ *
+ * Repeater fields are functionally identical to array fields. Each row in a
+ * repeater has the same structure defined by the `fields` property.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete repeater field configuration
+ *
+ * @example
+ * ```typescript
+ * repeater({
+ *   name: 'features',
+ *   fields: [
+ *     text({ name: 'title', required: true }),
+ *     textarea({ name: 'description' }),
+ *   ],
+ * })
+ * ```
+ */
+declare const repeater: (config: Omit<RepeaterFieldConfig, "type">) => RepeaterFieldConfig;
+/**
+ * Creates a group field configuration.
+ *
+ * Group fields organize related fields together. Named groups create
+ * nested data structures, while presentational groups just organize UI.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete group field configuration
+ *
+ * @example
+ * ```typescript
+ * // Named group (creates nested data)
+ * group({
+ *   name: 'seo',
+ *   fields: [
+ *     text({ name: 'metaTitle' }),
+ *     textarea({ name: 'metaDescription' }),
+ *   ],
+ * })
+ * // Data: { seo: { metaTitle: '...', metaDescription: '...' } }
+ *
+ * // Presentational group (no data nesting)
+ * group({
+ *   name: 'contactInfo',
+ *   admin: { hideGutter: true },
+ *   fields: [
+ *     email({ name: 'email' }),
+ *     text({ name: 'phone' }),
+ *   ],
+ * })
+ * ```
+ */
+declare const group: (config: Omit<GroupFieldConfig, "type">) => GroupFieldConfig;
+/**
+ * Creates a JSON field configuration.
+ *
+ * JSON fields store arbitrary JSON data with optional schema validation.
+ * Provides a Monaco-based JSON editor in the Admin UI.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete JSON field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic JSON field
+ * json({ name: 'metadata' })
+ *
+ * // JSON with schema validation
+ * json({
+ *   name: 'config',
+ *   jsonSchema: {
+ *     type: 'object',
+ *     properties: {
+ *       theme: { type: 'string', enum: ['light', 'dark'] },
+ *       maxItems: { type: 'number', minimum: 1 },
+ *     },
+ *     required: ['theme'],
+ *   },
+ * })
+ * ```
+ */
+declare const json: (config: Omit<JSONFieldConfig, "type">) => JSONFieldConfig;
+/**
+ * Creates a component field configuration.
+ *
+ * Component fields embed reusable Components within Collections, Singles,
+ * or other Components. Supports single component, multi-component (dynamic
+ * zone), and repeatable modes.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete component field configuration
+ *
+ * @example
+ * ```typescript
+ * // Single component (one specific type)
+ * component({ name: 'seo', component: 'seo' })
+ *
+ * // Multi-component / dynamic zone (editor picks type)
+ * component({
+ *   name: 'layout',
+ *   components: ['hero', 'cta', 'content'],
+ *   repeatable: true,
+ * })
+ *
+ * // Repeatable single component
+ * component({
+ *   name: 'features',
+ *   component: 'feature-card',
+ *   repeatable: true,
+ *   minRows: 1,
+ *   maxRows: 12,
+ * })
+ * ```
+ */
+declare const component: (config: Omit<ComponentFieldConfig, "type">) => ComponentFieldConfig;
+/**
+ * Creates a chips field configuration.
+ *
+ * Chips fields store an array of unique free-form string values.
+ * Renders as interactive chips/tags with add/remove capability.
+ * Duplicate values are automatically prevented.
+ *
+ * @param config - Field configuration without the `type` property
+ * @returns Complete chips field configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic chips field
+ * chips({ name: 'tags' })
+ *
+ * // Tags with limit
+ * chips({ name: 'keywords', maxChips: 10 })
+ *
+ * // Required with min/max
+ * chips({ name: 'categories', required: true, minChips: 1, maxChips: 5 })
+ * ```
+ */
+declare const chips: (config: Omit<ChipsFieldConfig, "type">) => ChipsFieldConfig;
+/**
+ * Creates a select option configuration.
+ *
+ * A convenient helper for creating select/radio options.
+ * If no value is provided, it's auto-generated from the label.
+ *
+ * @param label - Display text for the option
+ * @param value - Value stored in database (defaults to lowercase label with underscores)
+ * @returns Select option object
+ *
+ * @example
+ * ```typescript
+ * // Auto-generated values
+ * option('Draft')           // { label: 'Draft', value: 'draft' }
+ * option('In Progress')     // { label: 'In Progress', value: 'in_progress' }
+ * option('Published')       // { label: 'Published', value: 'published' }
+ *
+ * // Custom value
+ * option('Active', 'active')
+ * option('High Priority', 'high')
+ *
+ * // Used in select field
+ * select({
+ *   name: 'status',
+ *   options: [
+ *     option('Draft'),
+ *     option('In Review'),
+ *     option('Published'),
+ *   ],
+ * })
+ * ```
+ */
+declare const option: (label: string, value?: string) => SelectOption;
+
+/**
+ * Define Config Helper
+ *
+ * Provides the `defineConfig()` function for creating the main Nextly
+ * configuration file. This is the primary API for aggregating collections,
+ * singles, and configuring TypeScript/database output paths.
+ *
+ * Type definitions and the pure sanitization step live in
+ * `src/shared/types/config.ts`. This file keeps the validation logic
+ * (duplicate slugs, component nesting depth, user-field constraints)
+ * and re-exports the types for backwards compatibility.
+ *
+ * @module collections/config/define-config
+ * @since 1.0.0
+ *
+ * @example
+ * ```typescript
+ * // nextly.config.ts
+ * import { defineConfig } from '@nextly/core';
+ * import Posts from './src/collections/posts';
+ * import Users from './src/collections/users';
+ * import Media from './src/collections/media';
+ * import SiteSettings from './src/singles/site-settings';
+ *
+ * export default defineConfig({
+ *   collections: [Posts, Users, Media],
+ *   singles: [SiteSettings],
+ *   typescript: {
+ *     outputFile: './src/types/payload-types.ts',
+ *   },
+ * });
+ * ```
+ */
+
+/**
+ * Define the Nextly configuration for your application.
+ *
+ * This is the main entry point for configuring Nextly. It validates
+ * the configuration, applies sensible defaults via `sanitizeConfig()`,
+ * and returns a fully normalized config object.
+ *
+ * **Validation:**
+ * - Checks for duplicate collection slugs
+ * - Checks for duplicate single slugs
+ * - Checks for slug conflicts between collections and singles
+ * - Checks for component nesting depth and circular references
+ * - Validates user-field constraints
+ *
+ * **Defaults Applied (via sanitizeConfig):**
+ * - `collections`: `[]`
+ * - `singles`: `[]`
+ * - `components`: `[]`
+ * - `typescript.outputFile`: `'./src/types/generated/payload-types.ts'`
+ * - `typescript.declare`: `true`
+ * - `db.schemasDir`: `'./src/db/schemas/collections'`
+ * - `db.migrationsDir`: `'./src/db/migrations'`
+ * - `storage`: `[]`
+ * - `plugins`: `[]`
+ * - `rateLimit`: enabled with defaults (100 read / 30 write per minute)
+ *
+ * @param config - The Nextly configuration object
+ * @returns Normalized configuration with all defaults applied
+ * @throws Error if configuration is invalid (e.g., duplicate slugs)
+ */
+declare function defineConfig(config: NextlyConfig): SanitizedNextlyConfig;
+
+/**
+ * Define Single Helper
+ *
+ * Provides the `defineSingle()` function for creating code-first Single
+ * configurations with full TypeScript support. This is the primary API for
+ * defining Singles in TypeScript files.
+ *
+ * Singles are single-document entities for storing site-wide configuration
+ * such as site settings, navigation menus, footers, and homepage configurations.
+ *
+ * Key differences from Collections:
+ * - Only one document per Single (no list view)
+ * - No create/delete operations (auto-created on first access)
+ * - Simplified hooks (4 vs 8 for Collections)
+ * - Simplified access control (read/update only)
+ * - No timestamps configuration (always has updatedAt)
+ * - No pagination options
+ *
+ * @module singles/config/define-single
+ * @since 1.0.0
+ *
+ * @example
+ * ```typescript
+ * import { defineSingle, text, upload, array } from 'nextly';
+ *
+ * export default defineSingle({
+ *   slug: 'site-settings',
+ *   label: { singular: 'Site Settings' },
+ *   fields: [
+ *     text({ name: 'siteName', required: true }),
+ *     text({ name: 'tagline' }),
+ *     upload({ name: 'logo', relationTo: 'media' }),
+ *   ],
+ *   access: {
+ *     read: true,
+ *     update: ({ roles }) => roles.includes('admin'),
+ *   },
+ * });
+ * ```
+ */
+
+/**
+ * Define a code-first Single with full type safety.
+ *
+ * This is the primary API for creating Single configurations in TypeScript.
+ * It validates the configuration, applies sensible defaults, and returns a
+ * normalized `SingleConfig` object.
+ *
+ * **Defaults Applied:**
+ * - `label.singular`: Generated from slug (e.g., 'site-settings' → 'Site Settings')
+ * - `admin`: Empty object if not provided
+ *
+ * **Validation:**
+ * - Slug must be valid (lowercase, URL-friendly, not reserved)
+ * - Fields array must be non-empty
+ * - Access functions must be functions (if provided)
+ *
+ * @param config - The Single configuration
+ * @returns Normalized Single configuration with defaults applied
+ * @throws Error if configuration is invalid
+ *
+ * @example Basic Single
+ * ```typescript
+ * import { defineSingle, text } from 'nextly';
+ *
+ * export default defineSingle({
+ *   slug: 'site-settings',
+ *   fields: [
+ *     text({ name: 'siteName', required: true }),
+ *     text({ name: 'tagline' }),
+ *   ],
+ * });
+ * ```
+ *
+ * @example Single with Admin Options
+ * ```typescript
+ * import { defineSingle, text, upload, group, array } from 'nextly';
+ *
+ * export default defineSingle({
+ *   slug: 'site-settings',
+ *   label: { singular: 'Site Settings' },
+ *   admin: {
+ *     group: 'Settings',
+ *     icon: 'Settings',
+ *     description: 'Site configuration',
+ *   },
+ *   fields: [
+ *     text({ name: 'siteName', required: true, label: 'Site Name' }),
+ *     text({ name: 'tagline', label: 'Tagline' }),
+ *     upload({ name: 'logo', relationTo: 'media', label: 'Logo' }),
+ *     upload({ name: 'favicon', relationTo: 'media', label: 'Favicon' }),
+ *     group({
+ *       name: 'seo',
+ *       label: 'SEO Defaults',
+ *       fields: [
+ *         text({ name: 'metaTitle', label: 'Default Meta Title' }),
+ *         text({ name: 'metaDescription', label: 'Default Meta Description' }),
+ *       ],
+ *     }),
+ *     array({
+ *       name: 'socialLinks',
+ *       label: 'Social Links',
+ *       fields: [
+ *         text({ name: 'platform', required: true }),
+ *         text({ name: 'url', required: true }),
+ *       ],
+ *     }),
+ *   ],
+ *   access: {
+ *     read: () => true,
+ *     update: ({ req }) => req.user?.role === 'admin',
+ *   },
+ *   hooks: {
+ *     afterChange: [
+ *       async ({ doc }) => {
+ *         // Revalidate frontend cache
+ *         await fetch('/api/revalidate?tag=site-settings', { method: 'POST' });
+ *       },
+ *     ],
+ *   },
+ * });
+ * ```
+ *
+ * @example Header Navigation Single
+ * ```typescript
+ * import { defineSingle, array, text, relationship } from 'nextly';
+ *
+ * export default defineSingle({
+ *   slug: 'header',
+ *   label: { singular: 'Header Navigation' },
+ *   admin: {
+ *     group: 'Navigation',
+ *     icon: 'Menu',
+ *   },
+ *   fields: [
+ *     array({
+ *       name: 'navItems',
+ *       label: 'Navigation Items',
+ *       fields: [
+ *         text({ name: 'label', required: true }),
+ *         text({ name: 'url' }),
+ *         relationship({ name: 'page', relationTo: 'pages' }),
+ *       ],
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+declare function defineSingle(config: SingleConfig): SingleConfig;
+
+/**
+ * Define Component Helper
+ *
+ * Provides the `defineComponent()` function for creating code-first Component
+ * configurations with full TypeScript support. This is the primary API for
+ * defining Components (reusable field groups) in TypeScript files.
+ *
+ * Components are shared, reusable field structures that can be independently
+ * created and then selected from within Collections and Singles.
+ *
+ * Key characteristics:
+ * - Components are templates (schemas), not documents
+ * - Each instance is unique to its parent entry
+ * - Support all field types including nested components (max depth: 3)
+ * - Separate database table per component type (comp_{slug})
+ *
+ * @module components/config/define-component
+ * @since 1.0.0
+ *
+ * @example
+ * ```typescript
+ * import { defineComponent, text, upload } from 'nextly';
+ *
+ * export default defineComponent({
+ *   slug: 'seo',
+ *   label: { singular: 'SEO Metadata' },
+ *   admin: {
+ *     category: 'Shared',
+ *     icon: 'Search',
+ *     description: 'Search engine optimization metadata',
+ *   },
+ *   fields: [
+ *     text({ name: 'metaTitle', required: true, label: 'Meta Title' }),
+ *     text({ name: 'metaDescription', label: 'Meta Description' }),
+ *     upload({ name: 'metaImage', relationTo: 'media', label: 'OG Image' }),
+ *     text({ name: 'canonicalUrl', label: 'Canonical URL' }),
+ *   ],
+ * });
+ * ```
+ */
+
+/**
+ * Define a code-first Component with full type safety.
+ *
+ * This is the primary API for creating Component configurations in TypeScript.
+ * It validates the configuration, applies sensible defaults, and returns a
+ * normalized `ComponentConfig` object.
+ *
+ * **Defaults Applied:**
+ * - `label.singular`: Generated from slug (e.g., 'social-link' → 'Social Link')
+ * - `admin`: Empty object if not provided
+ *
+ * **Validation:**
+ * - Slug must be valid (lowercase, URL-friendly, not reserved)
+ * - Fields array must be non-empty
+ * - Component field references validated (single vs multi mode)
+ *
+ * @param config - The Component configuration
+ * @returns Normalized Component configuration with defaults applied
+ * @throws Error if configuration is invalid
+ *
+ * @example Basic Component
+ * ```typescript
+ * import { defineComponent, text } from 'nextly';
+ *
+ * export default defineComponent({
+ *   slug: 'seo',
+ *   fields: [
+ *     text({ name: 'metaTitle', required: true }),
+ *     text({ name: 'metaDescription' }),
+ *   ],
+ * });
+ * ```
+ *
+ * @example Component with Admin Options
+ * ```typescript
+ * import { defineComponent, text, upload, select } from 'nextly';
+ *
+ * export default defineComponent({
+ *   slug: 'hero',
+ *   label: { singular: 'Hero Section' },
+ *   admin: {
+ *     category: 'Blocks',
+ *     icon: 'Image',
+ *     description: 'Full-width hero banner with heading and CTA',
+ *   },
+ *   fields: [
+ *     text({ name: 'heading', required: true, label: 'Heading' }),
+ *     text({ name: 'subheading', label: 'Subheading' }),
+ *     upload({ name: 'backgroundImage', relationTo: 'media', label: 'Background Image' }),
+ *     text({ name: 'ctaText', label: 'CTA Button Text' }),
+ *     text({ name: 'ctaLink', label: 'CTA Button Link' }),
+ *     select({
+ *       name: 'alignment',
+ *       label: 'Content Alignment',
+ *       options: [
+ *         { label: 'Left', value: 'left' },
+ *         { label: 'Center', value: 'center' },
+ *         { label: 'Right', value: 'right' },
+ *       ],
+ *       defaultValue: 'center',
+ *     }),
+ *   ],
+ * });
+ * ```
+ *
+ * @example Component with Nested Component Field
+ * ```typescript
+ * import { defineComponent, text, component } from 'nextly';
+ *
+ * export default defineComponent({
+ *   slug: 'faq-item',
+ *   label: { singular: 'FAQ Item' },
+ *   fields: [
+ *     text({ name: 'question', required: true }),
+ *     text({ name: 'answer', required: true }),
+ *     component({ name: 'cta', component: 'cta' }),
+ *   ],
+ * });
+ * ```
+ */
+declare function defineComponent(config: ComponentConfig): ComponentConfig;
+
+export { isRepeaterField as A, isRichTextField as B, isSelectField as C, isTextField as D, isTextareaField as E, isUploadField as F, json as G, number as H, option as I, password as J, radio as K, relationship as L, repeater as M, richText as N, select as O, text as P, textarea as Q, upload as R, array as a, chips as b, checkbox as c, code as d, component as e, date as f, defineComponent as g, defineConfig as h, defineSingle as i, email as j, group as k, hasNestedFields as l, isCheckboxField as m, isChipsField as n, isCodeField as o, isComponentField as p, isDataField as q, isDateField as r, isEmailField as s, isGroupField as t, isJSONField as u, isNumberField as v, isPasswordField as w, isRadioField as x, isRelationalField as y, isRelationshipField as z };