@payloadcms/figma 0.0.1-alpha.9 → 0.1.0-alpha.0

package/dist/db-content-api/utilities/meta/buildMeta.d.ts

@@ -0,0 +1,41 @@
+import type { Payload, Where } from 'payload';
+import type { components } from '../../generated/content-api-types.js';
+import type { PathTypesRecord } from '../../temp-utilities/types.js';
+/**
+ * Metadata sent to Content API for query processing.
+ *
+ * TODO: This interface is defined here temporarily so Content API can test the integration.
+ * Once Content API implements support for pathTypes with relationship info, this type
+ * should be generated from openapi.json and ContentAPIMeta can be removed.
+ */
+export interface ContentAPIMeta {
+    localizedPaths?: string[];
+    pathTypes?: PathTypesRecord;
+    uniquePaths?: {
+        paths: string[];
+    }[];
+}
+/**
+ * The type that Content API currently expects (from generated types).
+ * This is more restrictive than ContentAPIMeta until Content API is updated.
+ */
+type ContentAPIMetaGenerated = components['schemas']['RequestMeta'];
+export interface BuildMetaOptions {
+    collection: string;
+    /** Document data — when provided, unique field constraints are included in meta. */
+    data?: Record<string, unknown>;
+    locale: string | undefined;
+    where?: Where;
+}
+/**
+ * Builds the `meta` object for Content API requests.
+ * Combines pathTypes (for array field handling) and localizedPaths (for locale queries).
+ *
+ * @param payload - The Payload instance
+ * @param options - Options including collection slug, locale, and where clause
+ * @returns Object with meta property ready to spread into request body, or empty object if no meta needed
+ */
+export declare function buildMeta(payload: Payload, options: BuildMetaOptions): {
+    meta?: ContentAPIMetaGenerated;
+};
+export {};

package/dist/db-content-api/utilities/meta/buildMeta.js

@@ -0,0 +1,39 @@
+import { buildLocalizedPaths } from './buildLocalizedPaths.js';
+import { buildPathTypes } from './buildPathTypes.js';
+import { buildUniquePaths } from './buildUniquePaths.js';
+/**
+ * Builds the `meta` object for Content API requests.
+ * Combines pathTypes (for array field handling) and localizedPaths (for locale queries).
+ *
+ * @param payload - The Payload instance
+ * @param options - Options including collection slug, locale, and where clause
+ * @returns Object with meta property ready to spread into request body, or empty object if no meta needed
+ */ export function buildMeta(payload, options) {
+    const { collection, data, locale, where } = options;
+    const meta = {};
+    // Add pathTypes if there are array fields in the where clause
+    const pathTypes = buildPathTypes(payload, collection, where);
+    if (Object.keys(pathTypes).length > 0) {
+        meta.pathTypes = pathTypes;
+    }
+    // Add localizedPaths if locale is specified (but not 'all')
+    if (locale && locale !== 'all') {
+        const localizedPaths = buildLocalizedPaths(payload, collection);
+        if (localizedPaths.length > 0) {
+            meta.localizedPaths = localizedPaths;
+        }
+    }
+    // Add uniquePaths when data is provided (create/upsert operations)
+    if (data) {
+        const uniquePaths = buildUniquePaths(payload, collection, data);
+        if (uniquePaths.length > 0) {
+            meta.uniquePaths = uniquePaths;
+        }
+    }
+    // Cast to generated type - Content API will need to be updated to handle
+    // the new pathTypes format with relationship info. Until then, it will
+    // ignore the extra fields but still receive the data for testing.
+    return Object.keys(meta).length > 0 ? {
+        meta: meta
+    } : {};
+}

package/dist/db-content-api/utilities/meta/buildPathTypes.d.ts

@@ -0,0 +1,16 @@
+import type { Payload, Where } from 'payload';
+import type { PathTypesRecord } from '../../temp-utilities/types.js';
+/**
+ * Builds pathTypes metadata for Content API request.
+ * Returns a record of paths with their types for proper query generation.
+ *
+ * Includes:
+ * - Array fields (type: "array")
+ * - Relationship fields (type: { type: "relationship", collection, hasMany })
+ * - Join fields (type: { type: "join", collection, hasMany, on })
+ *
+ * Localized array/blocks fields (stored as locale maps) are handled specially:
+ * - The localized field itself is NOT marked as 'array' (it's a locale map object)
+ * - The locale-specific path (e.g. "localizedBlocks.en") IS marked as 'array'
+ */
+export declare function buildPathTypes(payload: Payload, collectionSlug: string, where: undefined | Where): PathTypesRecord;

package/dist/db-content-api/utilities/meta/buildPathTypes.js

@@ -0,0 +1,243 @@
+import { resolveBlocks } from '../resolveBlocks.js';
+/**
+ * Extracts all field paths from a where clause recursively
+ */ function extractPathsFromWhere(where, paths = new Set()) {
+    if (!where || typeof where !== 'object') {
+        return paths;
+    }
+    // Handle 'and' operator
+    if ('and' in where && Array.isArray(where.and)) {
+        for (const clause of where.and){
+            extractPathsFromWhere(clause, paths);
+        }
+        return paths;
+    }
+    // Handle 'or' operator
+    if ('or' in where && Array.isArray(where.or)) {
+        for (const clause of where.or){
+            extractPathsFromWhere(clause, paths);
+        }
+        return paths;
+    }
+    // Handle regular conditions - keys are field paths
+    for(const key in where){
+        if (key === 'and' || key === 'or') {
+            continue;
+        }
+        // Add the path
+        paths.add(key.replace(/__/g, '.'));
+        // Check if the value is a nested where clause (for relationships)
+        const value = where[key];
+        if (value && typeof value === 'object' && !('equals' in value) && !('in' in value)) {
+            // Might be a nested where, recurse
+            extractPathsFromWhere(value, paths);
+        }
+    }
+    return paths;
+}
+/**
+ * Determines the type of a field based on its configuration.
+ * Returns PathTypeValue for fields that need special handling in Content API queries.
+ */ function getFieldType(field) {
+    // Array field
+    if (field.type === 'array') {
+        return 'array';
+    }
+    // Blocks field (array of objects)
+    if (field.type === 'blocks') {
+        return 'array';
+    }
+    // Relationship field - always include for JOIN support
+    if (field.type === 'relationship') {
+        const { hasMany = false, relationTo: collection } = field;
+        return {
+            type: 'relationship',
+            collection,
+            hasMany
+        };
+    }
+    // Upload field - treated like relationship
+    if (field.type === 'upload') {
+        const { hasMany = false, relationTo: collection } = field;
+        return {
+            type: 'relationship',
+            collection,
+            hasMany
+        };
+    }
+    // Join field - virtual reverse lookup
+    if (field.type === 'join') {
+        const { collection, on } = field;
+        return {
+            type: 'join',
+            collection,
+            hasMany: true,
+            on
+        };
+    }
+    // Text field with hasMany (array of strings)
+    if (field.type === 'text' && 'hasMany' in field && field.hasMany) {
+        return 'array';
+    }
+    // Number field with hasMany (array of numbers)
+    if (field.type === 'number' && 'hasMany' in field && field.hasMany) {
+        return 'array';
+    }
+    // Select field with hasMany (array)
+    if (field.type === 'select' && 'hasMany' in field && field.hasMany) {
+        return 'array';
+    }
+    // Objects (group, collapsible, row, tabs) don't need traversal
+    return null;
+}
+/**
+ * Finds a field in the collection schema by its path.
+ * Supports nested paths like "access.read.users".
+ * For localized array/blocks fields, locale key segments (e.g. "en") are skipped transparently,
+ * so "localizedBlocks.en.richText" resolves to the richText field inside localizedBlocks.
+ */ function findFieldByPath(payload, collectionSlug, path) {
+    const collectionConfig = payload.config.collections.find((c)=>c.slug === collectionSlug);
+    if (!collectionConfig) {
+        return undefined;
+    }
+    const localeCodes = payload.config.localization ? payload.config.localization.localeCodes : [];
+    const pathSegments = path.split('.');
+    // Walk through the path segments to find the field
+    let currentFields = collectionConfig.fields;
+    let currentField = undefined;
+    for(let i = 0; i < pathSegments.length; i++){
+        const segment = pathSegments[i];
+        // If this segment is a locale key for the previously found localized array/blocks field,
+        // skip it transparently (the locale key is the wrapping object key, not a real field).
+        if (localeCodes.includes(segment) && currentField && 'localized' in currentField && currentField.localized && (currentField.type === 'blocks' || currentField.type === 'array')) {
+            if (i === pathSegments.length - 1) {
+                // Last segment is a locale key → return the localized field (represents locale-specific array)
+                return currentField;
+            }
+            continue;
+        }
+        // First try to find a direct match
+        currentField = currentFields.find((f)=>'name' in f && f.name === segment);
+        // If not found, check if any unnamed container fields (collapsible, row) contain it
+        if (!currentField) {
+            for (const field of currentFields){
+                if (!('name' in field) || !field.name) {
+                    // This is an unnamed field, check its contents
+                    if ('fields' in field && field.type === 'collapsible' || 'fields' in field && field.type === 'row' || 'fields' in field && field.type === 'group') {
+                        currentField = field.fields.find((f)=>'name' in f && f.name === segment);
+                        if (currentField) {
+                            break;
+                        }
+                    } else if ('tabs' in field && field.type === 'tabs') {
+                        // Check all tabs
+                        for (const tab of field.tabs){
+                            // Named tab: the tab name itself is a path segment (acts like a group)
+                            if ('name' in tab && tab.name === segment) {
+                                currentField = {
+                                    name: tab.name,
+                                    type: 'group',
+                                    fields: tab.fields
+                                };
+                                break;
+                            }
+                            // Unnamed tab: search its fields for the segment
+                            const found = tab.fields.find((f)=>'name' in f && f.name === segment);
+                            if (found) {
+                                currentField = found;
+                                break;
+                            }
+                        }
+                        if (currentField) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if (!currentField) {
+            return undefined;
+        }
+        // If we're not at the end, get nested fields
+        if (i < pathSegments.length - 1) {
+            if (currentField.type === 'group' && 'fields' in currentField) {
+                currentFields = currentField.fields;
+            } else if (currentField.type === 'array' && 'fields' in currentField) {
+                currentFields = currentField.fields;
+            } else if (currentField.type === 'blocks' && 'blocks' in currentField) {
+                // Collect all fields from all block definitions to continue traversal
+                const allBlockFields = [];
+                for (const block of resolveBlocks(currentField.blocks, payload.config.blocks)){
+                    allBlockFields.push(...block.fields);
+                }
+                currentFields = allBlockFields;
+            } else if ((currentField.type === 'relationship' || currentField.type === 'upload') && typeof currentField.relationTo === 'string') {
+                // Traverse into the related collection's fields
+                const { relationTo } = currentField;
+                const relatedConfig = payload.config.collections.find((c)=>c.slug === relationTo);
+                if (relatedConfig) {
+                    currentFields = relatedConfig.fields;
+                } else {
+                    return undefined;
+                }
+            } else {
+                // Field doesn't have nested fields, can't continue
+                return undefined;
+            }
+        }
+    }
+    return currentField;
+}
+/**
+ * Builds pathTypes metadata for Content API request.
+ * Returns a record of paths with their types for proper query generation.
+ *
+ * Includes:
+ * - Array fields (type: "array")
+ * - Relationship fields (type: { type: "relationship", collection, hasMany })
+ * - Join fields (type: { type: "join", collection, hasMany, on })
+ *
+ * Localized array/blocks fields (stored as locale maps) are handled specially:
+ * - The localized field itself is NOT marked as 'array' (it's a locale map object)
+ * - The locale-specific path (e.g. "localizedBlocks.en") IS marked as 'array'
+ */ export function buildPathTypes(payload, collectionSlug, where) {
+    if (!where) {
+        return {};
+    }
+    const localeCodes = payload.config.localization ? payload.config.localization.localeCodes : [];
+    const pathTypes = {};
+    const paths = extractPathsFromWhere(where);
+    for (const path of paths){
+        // For each path, we need to check all segments to see if any intermediate ones are arrays/relationships
+        const segments = path.split('.');
+        for(let i = 0; i < segments.length; i++){
+            const partialPath = segments.slice(0, i + 1).join('.');
+            // Skip if we already have this path
+            if (partialPath in pathTypes) {
+                continue;
+            }
+            // If the current segment is a locale code and the parent field is a localized array/blocks,
+            // mark this locale-specific path as 'array' (the per-locale content is the actual array).
+            if (i > 0 && localeCodes.includes(segments[i])) {
+                const parentPath = segments.slice(0, i).join('.');
+                const parentField = findFieldByPath(payload, collectionSlug, parentPath);
+                if (parentField && 'localized' in parentField && parentField.localized && (parentField.type === 'blocks' || parentField.type === 'array')) {
+                    pathTypes[partialPath] = 'array';
+                    continue;
+                }
+            }
+            const field = findFieldByPath(payload, collectionSlug, partialPath);
+            if (field) {
+                // Localized array/blocks fields are stored as locale maps (not arrays).
+                // Skip them here — the locale-specific path (e.g. "localizedBlocks.en") is marked above.
+                if ('localized' in field && field.localized && (field.type === 'blocks' || field.type === 'array')) {
+                    continue;
+                }
+                const fieldType = getFieldType(field);
+                if (fieldType !== null) {
+                    pathTypes[partialPath] = fieldType;
+                }
+            }
+        }
+    }
+    return pathTypes;
+}

package/dist/db-content-api/utilities/meta/buildUniquePaths.d.ts

@@ -0,0 +1,12 @@
+import type { Payload } from 'payload';
+import type { components } from '../../generated/content-api-types.js';
+type UniquePath = components['schemas']['UniquePath'];
+/**
+ * Builds a UniquePath[] from the collection's field config by collecting
+ * all fields with `unique: true` that have a non-null value in the data.
+ *
+ * Fields with null/undefined values are excluded to match sparse unique index
+ * behavior (multiple documents can have null for a unique field).
+ */
+export declare function buildUniquePaths(payload: Payload, collectionSlug: string, data: Record<string, unknown>): UniquePath[];
+export {};

package/dist/db-content-api/utilities/meta/buildUniquePaths.js

@@ -0,0 +1,60 @@
+/**
+ * Builds a UniquePath[] from the collection's field config by collecting
+ * all fields with `unique: true` that have a non-null value in the data.
+ *
+ * Fields with null/undefined values are excluded to match sparse unique index
+ * behavior (multiple documents can have null for a unique field).
+ */ export function buildUniquePaths(payload, collectionSlug, data) {
+    const isGlobal = collectionSlug.startsWith('_global-');
+    const actualSlug = isGlobal ? collectionSlug.substring(8) : collectionSlug;
+    const config = isGlobal ? payload.config.globals?.find((g)=>g.slug === actualSlug) : payload.config.collections.find((c)=>c.slug === actualSlug);
+    if (!config?.fields) {
+        return [];
+    }
+    const unique = [];
+    collectUniqueFields(config.fields, '', data, unique);
+    return unique;
+}
+function getValueAtPath(data, path) {
+    const segments = path.split('.');
+    let current = data;
+    for (const segment of segments){
+        if (current == null || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function collectUniqueFields(fields, prefix, data, result) {
+    for (const field of fields){
+        if (field.type === 'row' || field.type === 'collapsible') {
+            collectUniqueFields(field.fields, prefix, data, result);
+            continue;
+        }
+        if (field.type === 'tabs') {
+            for (const tab of field.tabs){
+                const tabPrefix = 'name' in tab && tab.name ? `${prefix}${tab.name}.` : prefix;
+                collectUniqueFields(tab.fields, tabPrefix, data, result);
+            }
+            continue;
+        }
+        if (!('name' in field) || !field.name) {
+            continue;
+        }
+        const path = prefix + field.name;
+        if ('unique' in field && field.unique) {
+            const value = getValueAtPath(data, path);
+            if (value != null) {
+                result.push({
+                    paths: [
+                        path
+                    ]
+                });
+            }
+        }
+        if (field.type === 'group' && 'fields' in field) {
+            collectUniqueFields(field.fields, `${path}.`, data, result);
+        }
+    }
+}

package/dist/db-content-api/utilities/meta/normalizeLocaleInWhere.d.ts

@@ -0,0 +1,9 @@
+import type { Payload, Where } from 'payload';
+/**
+ * Normalizes a Where clause by inserting locale keys into paths that traverse
+ * localized array/blocks fields without an explicit locale.
+ *
+ * Only runs when a locale is provided and the collection has localized array/blocks fields.
+ * Returns the original where clause if no transformation is needed.
+ */
+export declare function normalizeLocaleInWhere(where: undefined | Where, payload: Payload, collectionSlug: string, locale: string | undefined): undefined | Where;

package/dist/db-content-api/utilities/meta/normalizeLocaleInWhere.js

@@ -0,0 +1,100 @@
+/**
+ * Collects paths of localized array/blocks fields in a collection.
+ * These fields are stored as locale maps (e.g. {"en": [...], "es": [...]}) rather than
+ * direct arrays, so queries must include the locale key in the path.
+ */ function collectLocalizedArrayPaths(fields, prefix, paths) {
+    for (const field of fields){
+        if (!('name' in field) || !field.name) {
+            // Unnamed container (row, collapsible) — recurse into its fields
+            if ('fields' in field && Array.isArray(field.fields)) {
+                collectLocalizedArrayPaths(field.fields, prefix, paths);
+            }
+            if ('tabs' in field && Array.isArray(field.tabs)) {
+                for (const tab of field.tabs){
+                    const tabPath = tab.name ? prefix ? `${prefix}.${tab.name}` : tab.name : prefix;
+                    if (tab.fields) {
+                        collectLocalizedArrayPaths(tab.fields, tabPath, paths);
+                    }
+                }
+            }
+            continue;
+        }
+        const fieldPath = prefix ? `${prefix}.${field.name}` : field.name;
+        if ('localized' in field && field.localized && (field.type === 'array' || field.type === 'blocks')) {
+            paths.push(fieldPath);
+        // Don't recurse further — child paths are accessed via locale key, handled separately
+        } else if (field.type === 'group' && 'fields' in field) {
+            collectLocalizedArrayPaths(field.fields, fieldPath, paths);
+        }
+    }
+}
+/**
+ * Returns the paths of all localized array/blocks fields for the given collection.
+ */ function getLocalizedArrayPaths(payload, collectionSlug) {
+    const config = payload.config.collections.find((c)=>c.slug === collectionSlug);
+    if (!config) {
+        return [];
+    }
+    const paths = [];
+    collectLocalizedArrayPaths(config.fields, '', paths);
+    return paths;
+}
+/**
+ * Transforms a single path by inserting the locale after a localized array/blocks prefix
+ * if the path goes through one without an explicit locale key.
+ *
+ * Example:
+ *   path "localizedBlocks.richText.children.text", localizedArrayPaths ["localizedBlocks"],
+ *   locale "en", localeCodes ["en", "es"]
+ *   → "localizedBlocks.en.richText.children.text"
+ *
+ *   path "localizedBlocks.en.richText.children.text" (already has locale)
+ *   → unchanged
+ */ function insertLocaleInPath(path, localizedArrayPaths, locale, localeCodes) {
+    for (const lpath of localizedArrayPaths){
+        if (path.startsWith(lpath + '.')) {
+            const rest = path.slice(lpath.length + 1);
+            const firstSegment = rest.split('.')[0];
+            if (!localeCodes.includes(firstSegment)) {
+                return `${lpath}.${locale}.${rest}`;
+            }
+        }
+    }
+    return path;
+}
+/**
+ * Recursively transforms all condition paths in a Where clause by inserting the locale key
+ * after any localized array/blocks field prefix that is missing one.
+ *
+ * This is needed because localized array/blocks fields are stored as locale maps
+ * (e.g. data.localizedBlocks.en = [...]) rather than flat arrays. Without the locale
+ * key, the path would point to the locale map object, causing jsonb_array_elements to fail.
+ */ function transformWhere(where, localizedArrayPaths, locale, localeCodes) {
+    const result = {};
+    for (const [key, value] of Object.entries(where)){
+        if (key === 'and' || key === 'or') {
+            result[key] = value.map((clause)=>transformWhere(clause, localizedArrayPaths, locale, localeCodes));
+        } else {
+            const normalizedKey = insertLocaleInPath(key, localizedArrayPaths, locale, localeCodes);
+            result[normalizedKey] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Normalizes a Where clause by inserting locale keys into paths that traverse
+ * localized array/blocks fields without an explicit locale.
+ *
+ * Only runs when a locale is provided and the collection has localized array/blocks fields.
+ * Returns the original where clause if no transformation is needed.
+ */ export function normalizeLocaleInWhere(where, payload, collectionSlug, locale) {
+    if (!where || !locale || !payload.config.localization) {
+        return where;
+    }
+    const localeCodes = payload.config.localization.localeCodes;
+    const localizedArrayPaths = getLocalizedArrayPaths(payload, collectionSlug);
+    if (localizedArrayPaths.length === 0) {
+        return where;
+    }
+    return transformWhere(where, localizedArrayPaths, locale, localeCodes);
+}

package/dist/db-content-api/utilities/resolveBlocks.d.ts

@@ -0,0 +1,19 @@
+import type { Block, FlattenedBlock } from 'payload';
+/**
+ * Dereferences a blocks field's entries into full block definitions.
+ *
+ * v4 stores block-reference-by-slug: a blocks field's `blocks` array may contain
+ * string slugs pointing at config-level shared blocks (`config.blocks`) instead of
+ * inline block definitions. Callers that need each block's `fields` must resolve
+ * those string references first. Unresolvable references are dropped.
+ */
+export declare function resolveBlocks(blocks: (Block | string)[], configBlocks?: FlattenedBlock[]): Block[];
+/**
+ * Resolves the flattened block definition matching a given `blockType`, following
+ * config-level string references. Returns `undefined` when no block matches.
+ */
+export declare function resolveFlattenedBlock({ blocks, blockType, configBlocks, }: {
+    blocks: (FlattenedBlock | string)[];
+    blockType: unknown;
+    configBlocks?: FlattenedBlock[];
+}): FlattenedBlock | undefined;

package/dist/db-content-api/utilities/resolveBlocks.js

@@ -0,0 +1,31 @@
+/**
+ * Dereferences a blocks field's entries into full block definitions.
+ *
+ * v4 stores block-reference-by-slug: a blocks field's `blocks` array may contain
+ * string slugs pointing at config-level shared blocks (`config.blocks`) instead of
+ * inline block definitions. Callers that need each block's `fields` must resolve
+ * those string references first. Unresolvable references are dropped.
+ */ export function resolveBlocks(blocks, configBlocks) {
+    const resolved = [];
+    for (const block of blocks){
+        if (typeof block !== 'string') {
+            resolved.push(block);
+            continue;
+        }
+        const match = configBlocks?.find((each)=>each.slug === block);
+        if (match) {
+            resolved.push(match);
+        }
+    }
+    return resolved;
+}
+/**
+ * Resolves the flattened block definition matching a given `blockType`, following
+ * config-level string references. Returns `undefined` when no block matches.
+ */ export function resolveFlattenedBlock({ blocks, blockType, configBlocks }) {
+    const match = blocks.find((each)=>(typeof each === 'string' ? each : each.slug) === blockType);
+    if (typeof match !== 'string') {
+        return match;
+    }
+    return configBlocks?.find((each)=>each.slug === match);
+}

package/dist/db-content-api/utilities/schema/buildDocumentSchema.d.ts

@@ -0,0 +1,55 @@
+import type { Config } from 'payload';
+/**
+ * Wire form of the v1 `DocumentSchema` sent on every request so the server can
+ * classify each queried path against the index tables. Paths are
+ * period-delimited (e.g. `author.name`).
+ */
+export interface DocumentSchemaWire {
+    collections: Record<string, WireCollectionSchema>;
+    version: 1;
+}
+interface WireCollectionSchema {
+    hints: WireHint[];
+    name: string;
+    paths: Record<string, WireFieldSchema>;
+}
+type WireHint = {
+    paths: string[];
+    type: 'unique';
+};
+type WireFieldSchema = {
+    collection: string | string[];
+    on: string;
+    type: 'join';
+} | {
+    collection: string | string[];
+    hasMany: boolean;
+    localized: boolean;
+    type: 'relationship' | 'upload';
+    unique: boolean;
+} | {
+    format: 'lexical';
+    localized: boolean;
+    type: 'richText';
+} | {
+    hasMany: boolean;
+    localized: boolean;
+    type: 'group';
+} | {
+    hasMany: boolean;
+    localized: boolean;
+    type: 'number' | 'select' | 'text';
+    unique: boolean;
+} | {
+    localized: boolean;
+    type: 'array' | 'blocks';
+} | {
+    localized: boolean;
+    type: 'checkbox' | 'date' | 'json' | 'radio';
+} | {
+    localized: boolean;
+    type: 'code' | 'email' | 'point' | 'textarea';
+    unique: boolean;
+};
+export declare function buildDocumentSchema(config: Config): DocumentSchemaWire;
+export {};