nextjs-cms 0.6.4 → 0.6.6

package/dist/core/fields/slug.d.ts

@@ -0,0 +1,245 @@
+import type { BaseFieldConfig } from './field.js';
+import { Field } from './field.js';
+import { entityKind } from '../helpers/index.js';
+import * as z from 'zod';
+import type { TextFieldConfig } from './text.js';
+/**
+ * Context passed to SlugField.prepareForSubmission for duplicate checking.
+ */
+export type SlugFieldSubmissionContext = {
+    tableName: string;
+};
+declare const slugFieldConfigSchema: z.ZodObject<{
+    placeholder: z.ZodOptional<z.ZodString>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    /**
+     * The default value of the field.
+     * If set, the field will be pre-populated with this value when the form is loaded.
+     */
+    defaultValue: z.ZodOptional<z.ZodString>;
+    /**
+     * The text field config that this slug field is derived from.
+     * When the source field's value changes, this field will automatically
+     * generate a slug from that value.
+     */
+    for: z.ZodCustom<{
+        type: "text";
+        build: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodCustom<import("./text.js").TextField, import("./text.js").TextField>>;
+        name: string;
+        placeholder?: string | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        defaultValue?: string | undefined;
+        sanitize?: boolean | undefined;
+        label?: string | Record<string, string> | undefined;
+        required?: boolean | undefined;
+        order?: number | undefined;
+        conditionalRules?: import("../types/index.js").ConditionalRule[] | undefined;
+        adminGenerated?: boolean | "readonly" | undefined;
+    }, {
+        type: "text";
+        build: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodCustom<import("./text.js").TextField, import("./text.js").TextField>>;
+        name: string;
+        placeholder?: string | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        defaultValue?: string | undefined;
+        sanitize?: boolean | undefined;
+        label?: string | Record<string, string> | undefined;
+        required?: boolean | undefined;
+        order?: number | undefined;
+        conditionalRules?: import("../types/index.js").ConditionalRule[] | undefined;
+        adminGenerated?: boolean | "readonly" | undefined;
+    }>;
+}, z.core.$strict>;
+type Config = z.infer<typeof slugFieldConfigSchema>;
+export declare class SlugField extends Field<'slug', Config> {
+    static readonly [entityKind]: string;
+    readonly maxLength: number | undefined;
+    readonly minLength: number | undefined;
+    readonly placeholder: string | undefined;
+    readonly forFieldName: string;
+    readonly forFieldConfig: TextFieldConfig;
+    private readonly _defaultValue;
+    value: string | undefined;
+    constructor(config: BaseFieldConfig<Config>);
+    /**
+     * Convert a string to a URL-friendly slug.
+     * - Converts to lowercase
+     * - Replaces spaces with hyphens
+     * - Removes special characters (keeps Unicode letters, numbers, and hyphens)
+     * - Removes leading/trailing hyphens
+     * - Collapses multiple consecutive hyphens into one
+     */
+    static toSlug(value: string): string;
+    exportForClient(): {
+        maxLength: number | undefined;
+        minLength: number | undefined;
+        placeholder: string | undefined;
+        forFieldName: string;
+        type: "slug";
+        name: string;
+        label: import("../../index.js").LocalizedString;
+        required: boolean;
+        conditionalFields: import("../types/index.js").ConditionalField[];
+        readonly: boolean;
+        defaultValue: any;
+        value: any;
+    };
+    /**
+     * Get the value of the field
+     */
+    getValue(): string | undefined;
+    checkRequired(): void;
+    hasSqlNameAndValue(): boolean;
+    /**
+     * Check if a slug already exists in the database table.
+     * Uses dynamic import to avoid loading db client during module initialization.
+     * @param tableName - The table to check for duplicates
+     * @returns true if a duplicate exists, false otherwise
+     */
+    private checkDuplicateSlug;
+    /**
+     * Get a user-friendly label for the "for" field.
+     * Falls back to the field name if no label is available.
+     */
+    private getForFieldLabel;
+    /**
+     * Prepare the field for submission
+     * @param context - Optional context containing tableName for duplicate checking
+     */
+    prepareForSubmission(context?: SlugFieldSubmissionContext): Promise<void>;
+}
+export type SlugFieldClientConfig = ReturnType<SlugField['exportForClient']>;
+declare const optionsSchema: z.ZodObject<{
+    placeholder: z.ZodOptional<z.ZodString>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    /**
+     * The default value of the field.
+     * If set, the field will be pre-populated with this value when the form is loaded.
+     */
+    defaultValue: z.ZodOptional<z.ZodString>;
+    /**
+     * The text field config that this slug field is derived from.
+     * When the source field's value changes, this field will automatically
+     * generate a slug from that value.
+     */
+    for: z.ZodCustom<{
+        type: "text";
+        build: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodCustom<import("./text.js").TextField, import("./text.js").TextField>>;
+        name: string;
+        placeholder?: string | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        defaultValue?: string | undefined;
+        sanitize?: boolean | undefined;
+        label?: string | Record<string, string> | undefined;
+        required?: boolean | undefined;
+        order?: number | undefined;
+        conditionalRules?: import("../types/index.js").ConditionalRule[] | undefined;
+        adminGenerated?: boolean | "readonly" | undefined;
+    }, {
+        type: "text";
+        build: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodCustom<import("./text.js").TextField, import("./text.js").TextField>>;
+        name: string;
+        placeholder?: string | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        defaultValue?: string | undefined;
+        sanitize?: boolean | undefined;
+        label?: string | Record<string, string> | undefined;
+        required?: boolean | undefined;
+        order?: number | undefined;
+        conditionalRules?: import("../types/index.js").ConditionalRule[] | undefined;
+        adminGenerated?: boolean | "readonly" | undefined;
+    }>;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodOptional<z.ZodNumber>;
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types/index.js").ConditionalRule, import("../types/index.js").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>;
+declare const configSchema: z.ZodObject<{
+    type: z.ZodLiteral<"slug">;
+    build: z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodCustom<SlugField, SlugField>>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    /**
+     * The default value of the field.
+     * If set, the field will be pre-populated with this value when the form is loaded.
+     */
+    defaultValue: z.ZodOptional<z.ZodString>;
+    /**
+     * The text field config that this slug field is derived from.
+     * When the source field's value changes, this field will automatically
+     * generate a slug from that value.
+     */
+    for: z.ZodCustom<{
+        type: "text";
+        build: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodCustom<import("./text.js").TextField, import("./text.js").TextField>>;
+        name: string;
+        placeholder?: string | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        defaultValue?: string | undefined;
+        sanitize?: boolean | undefined;
+        label?: string | Record<string, string> | undefined;
+        required?: boolean | undefined;
+        order?: number | undefined;
+        conditionalRules?: import("../types/index.js").ConditionalRule[] | undefined;
+        adminGenerated?: boolean | "readonly" | undefined;
+    }, {
+        type: "text";
+        build: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodCustom<import("./text.js").TextField, import("./text.js").TextField>>;
+        name: string;
+        placeholder?: string | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        defaultValue?: string | undefined;
+        sanitize?: boolean | undefined;
+        label?: string | Record<string, string> | undefined;
+        required?: boolean | undefined;
+        order?: number | undefined;
+        conditionalRules?: import("../types/index.js").ConditionalRule[] | undefined;
+        adminGenerated?: boolean | "readonly" | undefined;
+    }>;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodOptional<z.ZodNumber>;
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types/index.js").ConditionalRule, import("../types/index.js").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>;
+/**
+ * Slug field configuration type
+ * This is a plain object that can be serialized and used anywhere
+ * The build() method allows creating a SlugField instance when needed
+ */
+export type SlugFieldConfig = z.infer<typeof configSchema>;
+/**
+ * Helper function to create a slug field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ *
+ * @example
+ * ```typescript
+ * const titleField = textField({ name: 'title', label: 'Title', required: true })
+ * const slugFieldConfig = slugField({
+ *     name: 'slug',
+ *     label: 'URL Slug',
+ *     for: titleField,
+ *     required: true,
+ *     order: 2
+ * })
+ * // The slug field will automatically generate a slug from the title field's value
+ * const fieldInstance = slugFieldConfig.build()
+ * ```
+ *
+ * @param field
+ */
+export declare function slugField(field: z.infer<typeof optionsSchema>): SlugFieldConfig;
+export {};
+//# sourceMappingURL=slug.d.ts.map

package/dist/core/fields/slug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slug.d.ts","sourceRoot":"","sources":["../../../src/core/fields/slug.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,EAAE,KAAK,EAAyB,MAAM,YAAY,CAAA;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAChD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAGhD;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACrC,SAAS,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,QAAA,MAAM,qBAAqB;;;;IAIvB;;;OAGG;;IAEH;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEL,CAAA;AAEF,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnD,qBAAa,SAAU,SAAQ,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC;IAChD,gBAAyB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAc;IAC3D,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IACxC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,cAAc,EAAE,eAAe,CAAA;IACxC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoB;IACzC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;gBAEtB,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC;IAW3C;;;;;;;OAOG;IACH,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAUpB,eAAe;;;;;;;;;;;;;;IAU/B;;OAEG;IACH,QAAQ,IAAI,MAAM,GAAG,SAAS;IAI9B,aAAa;IAQJ,kBAAkB,IAAI,OAAO;IAOtC;;;;;OAKG;YACW,kBAAkB;IAmBhC;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IASxB;;;OAGG;IACG,oBAAoB,CAAC,OAAO,CAAC,EAAE,0BAA0B;CAuClE;AAED,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC,CAAA;AAE5E,QAAA,MAAM,aAAa;;;;IA3Kf;;;OAGG;;IAEH;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqKL,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;IAhLd;;;OAGG;;IAEH;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2KL,CAAA;AAEF;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAE1D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,GAAG,eAAe,CAkB/E"}

package/dist/core/fields/slug.js

@@ -0,0 +1,200 @@
+import { Field, baseFieldConfigSchema } from './field.js';
+import { entityKind } from '../helpers/index.js';
+import * as z from 'zod';
+import { resolveLocalizedString } from '../../translations/localization.js';
+const slugFieldConfigSchema = z.strictObject({
+    placeholder: z.string().optional().describe('The placeholder text for the field'),
+    minLength: z.number().optional().describe('The minimum length of the slug'),
+    maxLength: z.number().optional().describe('The maximum length of the slug'),
+    /**
+     * The default value of the field.
+     * If set, the field will be pre-populated with this value when the form is loaded.
+     */
+    defaultValue: z.string().optional().describe('The default value of the field'),
+    /**
+     * The text field config that this slug field is derived from.
+     * When the source field's value changes, this field will automatically
+     * generate a slug from that value.
+     */
+    for: z.custom().describe('The text field config this slug is derived from'),
+});
+export class SlugField extends Field {
+    static [entityKind] = 'SlugField';
+    maxLength;
+    minLength;
+    placeholder;
+    forFieldName;
+    forFieldConfig;
+    _defaultValue;
+    value;
+    constructor(config) {
+        super(config, 'slug');
+        this.maxLength = config.maxLength;
+        this.minLength = config.minLength;
+        this.placeholder = config.placeholder;
+        this.value = config.defaultValue;
+        this._defaultValue = config.defaultValue;
+        this.forFieldName = config.for.name;
+        this.forFieldConfig = config.for;
+    }
+    /**
+     * Convert a string to a URL-friendly slug.
+     * - Converts to lowercase
+     * - Replaces spaces with hyphens
+     * - Removes special characters (keeps Unicode letters, numbers, and hyphens)
+     * - Removes leading/trailing hyphens
+     * - Collapses multiple consecutive hyphens into one
+     */
+    static toSlug(value) {
+        return value
+            .toLowerCase()
+            .trim()
+            .replace(/\s+/g, '-') // Replace spaces with hyphens
+            .replace(/[^\p{L}\p{N}-]/gu, '') // Remove special characters (keep Unicode letters/numbers)
+            .replace(/-+/g, '-') // Collapse multiple hyphens
+            .replace(/^-|-$/g, ''); // Remove leading/trailing hyphens
+    }
+    exportForClient() {
+        return {
+            ...super.exportForClient(),
+            maxLength: this.maxLength,
+            minLength: this.minLength,
+            placeholder: this.placeholder,
+            forFieldName: this.forFieldName,
+        };
+    }
+    /**
+     * Get the value of the field
+     */
+    getValue() {
+        return this.value;
+    }
+    checkRequired() {
+        if (this.required) {
+            if (!this.value || this.value.trim().length === 0) {
+                throw new Error(`Field ${this.label} is required`);
+            }
+        }
+    }
+    hasSqlNameAndValue() {
+        /**
+         * Include the field in the SQL if it is admin-generated, or not admin-generated but has a default value
+         */
+        return this.adminGenerated === true || this._defaultValue !== undefined;
+    }
+    /**
+     * Check if a slug already exists in the database table.
+     * Uses dynamic import to avoid loading db client during module initialization.
+     * @param tableName - The table to check for duplicates
+     * @returns true if a duplicate exists, false otherwise
+     */
+    async checkDuplicateSlug(tableName) {
+        if (!this.value)
+            return false;
+        // Dynamic imports to avoid loading db client during module initialization
+        const { sql } = await import('drizzle-orm');
+        const { db } = await import('../../db/client.js');
+        const [rows] = await db.execute(sql `SELECT COUNT(*) as count FROM ${sql.raw(tableName)} WHERE ${sql.raw(this.name)} = ${this.value}`);
+        if (Array.isArray(rows) && rows.length > 0) {
+            const count = Number(rows[0].count);
+            return count > 0;
+        }
+        return false;
+    }
+    /**
+     * Get a user-friendly label for the "for" field.
+     * Falls back to the field name if no label is available.
+     */
+    getForFieldLabel() {
+        const label = this.forFieldConfig.label;
+        if (!label) {
+            return Field.generateLabel(this.forFieldName);
+        }
+        // Resolve localized string with English as fallback
+        return resolveLocalizedString(label, 'en', 'en');
+    }
+    /**
+     * Prepare the field for submission
+     * @param context - Optional context containing tableName for duplicate checking
+     */
+    async prepareForSubmission(context) {
+        if (this.value) {
+            // Ensure the value is a valid slug
+            this.value = SlugField.toSlug(this.value);
+            /**
+             * Check minimum length
+             */
+            if (this.minLength) {
+                if (this.minLength > this.value.length) {
+                    throw new Error(`Field ${this.label} must be at least ${this.minLength} characters long`);
+                }
+            }
+            /**
+             * Check maximum length
+             */
+            if (this.maxLength) {
+                if (this.maxLength < this.value.length) {
+                    throw new Error(`Field ${this.label} must be at most ${this.maxLength} characters long`);
+                }
+            }
+            /**
+             * Check for duplicate slugs in the database
+             */
+            if (context?.tableName) {
+                const isDuplicate = await this.checkDuplicateSlug(context.tableName);
+                if (isDuplicate) {
+                    const forFieldLabel = this.getForFieldLabel();
+                    throw new Error(`A record with the slug "${this.value}" already exists. ` +
+                        `Please change the "${forFieldLabel}" field to generate a different slug, ` +
+                        `or manually edit the slug value (not recommended).`);
+                }
+            }
+        }
+    }
+}
+const optionsSchema = z.strictObject({
+    ...baseFieldConfigSchema.shape,
+    ...slugFieldConfigSchema.shape,
+});
+const configSchema = z.strictObject({
+    ...optionsSchema.shape,
+    type: z.literal('slug').describe('The type of the field'),
+    build: z.function().output(z.instanceof(SlugField)).describe('Build a SlugField instance from this config'),
+});
+/**
+ * Helper function to create a slug field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ *
+ * @example
+ * ```typescript
+ * const titleField = textField({ name: 'title', label: 'Title', required: true })
+ * const slugFieldConfig = slugField({
+ *     name: 'slug',
+ *     label: 'URL Slug',
+ *     for: titleField,
+ *     required: true,
+ *     order: 2
+ * })
+ * // The slug field will automatically generate a slug from the title field's value
+ * const fieldInstance = slugFieldConfig.build()
+ * ```
+ *
+ * @param field
+ */
+export function slugField(field) {
+    /**
+     * Validate the field config
+     */
+    const result = optionsSchema.safeParse(field);
+    if (!result.success) {
+        throw new Error(`[Field: ${field.name}]: ${z.prettifyError(result.error)}`);
+    }
+    const config = {
+        ...field,
+        type: 'slug',
+        build() {
+            return new SlugField(field);
+        },
+    };
+    return config;
+}

package/dist/core/sections/category.d.ts

@@ -118,23 +118,9 @@ declare const optionsSchema: z.ZodObject<{
      */
     allowRecursiveDelete: z.ZodOptional<z.ZodBoolean>;
     fields: z.ZodUnion<[z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>, z.ZodArray<z.ZodCustom<FieldGroupConfig, FieldGroupConfig>>]>;
-    name: z.ZodString;
-    gallery: z.ZodOptional<z.ZodObject<{
-        db: z.ZodObject<{
-            tableName: z.ZodString;
-            identifierField: z.ZodOptional<z.ZodString>;
-            photoNameField: z.ZodOptional<z.ZodString>;
-            metaField: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>;
-        watermark: z.ZodOptional<z.ZodBoolean>;
-        thumbnail: z.ZodOptional<z.ZodObject<{
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-            crop: z.ZodBoolean;
-            quality: z.ZodNumber;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
     readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    name: z.ZodString;
+    order: z.ZodNumber;
     icon: z.ZodOptional<z.ZodString>;
     db: z.ZodObject<{
         table: z.ZodString;
@@ -160,7 +146,21 @@ declare const optionsSchema: z.ZodObject<{
         }, z.core.$strict>>>;
     }, z.core.$strict>;
     variants: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types/index.js").Variant, import("../types/index.js").Variant>>>;
-    order: z.ZodNumber;
+    gallery: z.ZodOptional<z.ZodObject<{
+        db: z.ZodObject<{
+            tableName: z.ZodString;
+            identifierField: z.ZodOptional<z.ZodString>;
+            photoNameField: z.ZodOptional<z.ZodString>;
+            metaField: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        watermark: z.ZodOptional<z.ZodBoolean>;
+        thumbnail: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            crop: z.ZodBoolean;
+            quality: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     hooks: z.ZodOptional<z.ZodCustom<import("./section.js").Hooks, import("./section.js").Hooks>>;
 }, z.core.$strict>;
 export declare const categorySectionConfigSchema: z.ZodObject<{
@@ -215,23 +215,9 @@ export declare const categorySectionConfigSchema: z.ZodObject<{
      * @default false
      */
     allowRecursiveDelete: z.ZodOptional<z.ZodBoolean>;
-    name: z.ZodString;
-    gallery: z.ZodOptional<z.ZodObject<{
-        db: z.ZodObject<{
-            tableName: z.ZodString;
-            identifierField: z.ZodOptional<z.ZodString>;
-            photoNameField: z.ZodOptional<z.ZodString>;
-            metaField: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>;
-        watermark: z.ZodOptional<z.ZodBoolean>;
-        thumbnail: z.ZodOptional<z.ZodObject<{
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-            crop: z.ZodBoolean;
-            quality: z.ZodNumber;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
     readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    name: z.ZodString;
+    order: z.ZodNumber;
     icon: z.ZodOptional<z.ZodString>;
     db: z.ZodObject<{
         table: z.ZodString;
@@ -257,7 +243,21 @@ export declare const categorySectionConfigSchema: z.ZodObject<{
         }, z.core.$strict>>>;
     }, z.core.$strict>;
     variants: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types/index.js").Variant, import("../types/index.js").Variant>>>;
-    order: z.ZodNumber;
+    gallery: z.ZodOptional<z.ZodObject<{
+        db: z.ZodObject<{
+            tableName: z.ZodString;
+            identifierField: z.ZodOptional<z.ZodString>;
+            photoNameField: z.ZodOptional<z.ZodString>;
+            metaField: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        watermark: z.ZodOptional<z.ZodBoolean>;
+        thumbnail: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            crop: z.ZodBoolean;
+            quality: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     hooks: z.ZodOptional<z.ZodCustom<import("./section.js").Hooks, import("./section.js").Hooks>>;
 }, z.core.$strict>;
 export type CategorySectionOptions = z.infer<typeof optionsSchema>;