payload 3.0.0-beta.78 → 3.0.0-beta.79

package/dist/fields/config/types.d.ts

@@ -1,18 +1,17 @@
 import type { EditorProps } from '@monaco-editor/react';
-import type { CSSProperties } from 'react';
 import type { JSONSchema4 } from 'json-schema';
-import type React from 'react';
+import type { CSSProperties } from 'react';
+import type { DeepUndefinable } from 'ts-essentials';
 import type { RichTextAdapter, RichTextAdapterProvider } from '../../admin/RichText.js';
 import type { ErrorComponent } from '../../admin/forms/Error.js';
-import type { ConditionalDateProps, Description, DescriptionComponent, LabelComponent, RowLabelComponent } from '../../admin/types.js';
+import type { ClientTab, ConditionalDateProps, Description, DescriptionComponent, LabelComponent, MappedComponent, RowLabelComponent, StaticDescription } from '../../admin/types.js';
 import type { SanitizedCollectionConfig, TypeWithID } from '../../collections/config/types.js';
-import type { CustomComponent, LabelFunction, LabelStatic } from '../../config/types.js';
+import type { CustomComponent, LabelFunction, PayloadComponent, StaticLabel } from '../../config/types.js';
 import type { DBIdentifierName } from '../../database/types.js';
 import type { SanitizedGlobalConfig } from '../../globals/config/types.js';
 import type { CollectionSlug } from '../../index.js';
 import type { DocumentPreferences } from '../../preferences/types.js';
 import type { Operation, PayloadRequest, RequestContext, Where } from '../../types/index.js';
-import type { ClientFieldConfig } from './client.js';
 export type FieldHookArgs<TData extends TypeWithID = any, TValue = any, TSiblingData = any> = {
     /** The collection which the field belongs to. If the field belongs to a global, this will be null. */
     collection: SanitizedCollectionConfig | null;
@@ -120,7 +119,7 @@ type Admin = {
         /**
          * The Filter component has to be a client component
          */
-        Filter?: React.ComponentType<any>;
+        Filter?: PayloadComponent;
     };
     /**
      * You can programmatically show / hide fields based on what other fields are doing.
@@ -148,9 +147,45 @@ type Admin = {
     style?: CSSProperties;
     width?: string;
 };
+export type AdminClient = {
+    className?: string;
+    components?: {
+        Cell?: MappedComponent;
+        Description?: MappedComponent;
+        Field?: MappedComponent;
+        /**
+         * The Filter component has to be a client component
+         */
+        Filter?: MappedComponent;
+    };
+    /** Extension point to add your custom data. Available in server and client. */
+    custom?: Record<string, any>;
+    description?: StaticDescription;
+    disableBulkEdit?: boolean;
+    /**
+     * Shows / hides fields from appearing in the list view column selector.
+     * @type boolean
+     */
+    disableListColumn?: boolean;
+    /**
+     * Shows / hides fields from appearing in the list view filter options.
+     * @type boolean
+     */
+    disableListFilter?: boolean;
+    disabled?: boolean;
+    hidden?: boolean;
+    position?: 'sidebar';
+    readOnly?: boolean;
+    style?: CSSProperties;
+    width?: string;
+};
 export type Labels = {
-    plural: LabelFunction | LabelStatic;
-    singular: LabelFunction | LabelStatic;
+    plural: LabelFunction | StaticLabel;
+    singular: LabelFunction | StaticLabel;
+};
+export type LabelsClient = {
+    plural: StaticLabel;
+    singular: StaticLabel;
 };
 export type BaseValidateOptions<TData, TSiblingData, TValue> = {
     collectionSlug?: string;
@@ -166,11 +201,16 @@ export type BaseValidateOptions<TData, TSiblingData, TValue> = {
 export type ValidateOptions<TData, TSiblingData, TFieldConfig extends object, TValue> = BaseValidateOptions<TData, TSiblingData, TValue> & TFieldConfig;
 export type Validate<TValue = any, TData = any, TSiblingData = any, TFieldConfig extends object = object> = (value: TValue, options: ValidateOptions<TData, TSiblingData, TFieldConfig, TValue>) => Promise<string | true> | string | true;
 export type OptionObject = {
-    label: LabelFunction | LabelStatic;
+    label: LabelFunction | StaticLabel;
     value: string;
 };
 export type Option = OptionObject | string;
 export interface FieldBase {
+    /**
+     * Do not set this property manually. This is set to true during sanitization, to avoid
+     * sanitizing the same field multiple times.
+     */
+    _sanitized?: boolean;
     access?: {
         create?: FieldAccess;
         read?: FieldAccess;
@@ -192,7 +232,7 @@ export interface FieldBase {
         beforeValidate?: FieldHook[];
     };
     index?: boolean;
-    label?: LabelFunction | LabelStatic | false;
+    label?: LabelFunction | StaticLabel | false;
     localized?: boolean;
     /**
      * The name of the field. Must be alphanumeric and cannot contain ' . '
@@ -213,6 +253,33 @@ export interface FieldBase {
     unique?: boolean;
     validate?: Validate;
 }
+export interface FieldBaseClient {
+    _isPresentational?: undefined;
+    _path?: string;
+    _schemaPath?: string;
+    admin?: AdminClient;
+    hidden?: boolean;
+    index?: boolean;
+    label?: StaticLabel;
+    localized?: boolean;
+    /**
+     * The name of the field. Must be alphanumeric and cannot contain ' . '
+     *
+     * Must not be one of reserved field names: ['__v', 'salt', 'hash', 'file']
+     * @link https://payloadcms.com/docs/fields/overview#field-names
+     */
+    name?: string;
+    required?: boolean;
+    saveToJWT?: boolean | string;
+    /**
+     * Allows you to modify the base JSON schema that is generated during generate:types for this field.
+     * This JSON schema will be used to generate the TypeScript interface of this field.
+     */
+    typescriptSchema?: Array<(args: {
+        jsonSchema: JSONSchema4;
+    }) => JSONSchema4>;
+    unique?: boolean;
+}
 export type NumberField = {
     admin?: {
         /** Set this property to a string that will be used for browser autocomplete. */
@@ -222,7 +289,7 @@ export type NumberField = {
             Label?: LabelComponent;
             afterInput?: CustomComponent[];
             beforeInput?: CustomComponent[];
-        };
+        } & Admin['components'];
         /** Set this property to define a placeholder string for the field. */
         placeholder?: Record<string, string> | string;
         /** Set a value for the number field to increment / decrement using browser controls. */
@@ -249,6 +316,16 @@ export type NumberField = {
     /** Minimum number of numbers in the numbers array, if `hasMany` is set to true. */
     minRows?: undefined;
 }) & FieldBase;
+export type NumberFieldClient = {
+    admin?: {
+        components?: {
+            Error?: MappedComponent;
+            Label?: MappedComponent;
+            afterInput?: MappedComponent[];
+            beforeInput?: MappedComponent[];
+        } & AdminClient['components'];
+    } & AdminClient & Pick<NumberField['admin'], 'autoComplete' | 'placeholder' | 'step'>;
+} & FieldBaseClient & Pick<NumberField, 'hasMany' | 'max' | 'maxRows' | 'min' | 'minRows' | 'type'>;
 export type TextField = {
     admin?: {
         autoComplete?: string;
@@ -257,7 +334,7 @@ export type TextField = {
             Label?: LabelComponent;
             afterInput?: CustomComponent[];
             beforeInput?: CustomComponent[];
-        };
+        } & Admin['components'];
         placeholder?: Record<string, string> | string;
         rtl?: boolean;
     } & Admin;
@@ -280,6 +357,16 @@ export type TextField = {
     /** Minimum number of strings in the strings array, if `hasMany` is set to true. */
     minRows?: undefined;
 }) & FieldBase;
+export type TextFieldClient = {
+    admin?: {
+        components?: {
+            Error?: MappedComponent;
+            Label?: MappedComponent;
+            afterInput?: MappedComponent[];
+            beforeInput?: MappedComponent[];
+        } & AdminClient['components'];
+    } & AdminClient & Pick<TextField['admin'], 'autoComplete' | 'placeholder' | 'rtl'>;
+} & FieldBaseClient & Pick<TextField, 'hasMany' | 'maxLength' | 'maxRows' | 'minLength' | 'minRows' | 'type'>;
 export type EmailField = {
     admin?: {
         autoComplete?: string;
@@ -288,12 +375,22 @@ export type EmailField = {
             Label?: LabelComponent;
             afterInput?: CustomComponent[];
             beforeInput?: CustomComponent[];
-        };
+        } & Admin['components'];
         placeholder?: Record<string, string> | string;
     } & Admin;
     type: 'email';
     validate?: Validate<string, unknown, unknown, EmailField>;
 } & FieldBase;
+export type EmailFieldClient = {
+    admin?: {
+        components?: {
+            Error?: MappedComponent;
+            Label?: MappedComponent;
+            afterInput?: MappedComponent[];
+            beforeInput?: MappedComponent[];
+        } & AdminClient['components'];
+    } & AdminClient & Pick<EmailField['admin'], 'placeholder'>;
+} & FieldBaseClient & Pick<EmailField, 'type'>;
 export type TextareaField = {
     admin?: {
         components?: {
@@ -301,7 +398,7 @@ export type TextareaField = {
             Label?: LabelComponent;
             afterInput?: CustomComponent[];
             beforeInput?: CustomComponent[];
-        };
+        } & Admin['components'];
         placeholder?: Record<string, string> | string;
         rows?: number;
         rtl?: boolean;
@@ -311,6 +408,16 @@ export type TextareaField = {
     type: 'textarea';
     validate?: Validate<string, unknown, unknown, TextareaField>;
 } & FieldBase;
+export type TextareaFieldClient = {
+    admin?: {
+        components?: {
+            Error?: MappedComponent;
+            Label?: MappedComponent;
+            afterInput?: MappedComponent[];
+            beforeInput?: MappedComponent[];
+        } & AdminClient['components'];
+    } & AdminClient & Pick<TextareaField['admin'], 'placeholder' | 'rows' | 'rtl'>;
+} & FieldBaseClient & Pick<TextareaField, 'maxLength' | 'minLength' | 'type'>;
 export type CheckboxField = {
     admin?: {
         components?: {
@@ -318,11 +425,21 @@ export type CheckboxField = {
             Label?: LabelComponent;
             afterInput?: CustomComponent[];
             beforeInput?: CustomComponent[];
-        };
+        } & Admin['components'];
     } & Admin;
     type: 'checkbox';
     validate?: Validate<unknown, unknown, unknown, CheckboxField>;
 } & FieldBase;
+export type CheckboxFieldClient = {
+    admin?: {
+        components?: {
+            Error?: MappedComponent;
+            Label?: MappedComponent;
+            afterInput?: MappedComponent[];
+            beforeInput?: MappedComponent[];
+        } & AdminClient['components'];
+    } & AdminClient;
+} & FieldBaseClient & Pick<CheckboxField, 'type'>;
 export type DateField = {
     admin?: {
         components?: {
@@ -330,15 +447,28 @@ export type DateField = {
             Label?: LabelComponent;
             afterInput?: CustomComponent[];
             beforeInput?: CustomComponent[];
-        };
+        } & Admin['components'];
         date?: ConditionalDateProps;
         placeholder?: Record<string, string> | string;
     } & Admin;
     type: 'date';
     validate?: Validate<unknown, unknown, unknown, DateField>;
 } & FieldBase;
+export type DateFieldClient = {
+    admin?: {
+        components?: {
+            Error?: MappedComponent;
+            Label?: MappedComponent;
+            afterInput?: MappedComponent[];
+            beforeInput?: MappedComponent[];
+        } & AdminClient['components'];
+    } & AdminClient & Pick<DateField['admin'], 'date' | 'placeholder'>;
+} & FieldBaseClient & Pick<DateField, 'type'>;
 export type GroupField = {
     admin?: {
+        components?: {
+            Label?: LabelComponent;
+        } & Admin['components'];
         hideGutter?: boolean;
     } & Admin;
     fields: Field[];
@@ -352,18 +482,30 @@ export type GroupField = {
     type: 'group';
     validate?: Validate<unknown, unknown, unknown, GroupField>;
 } & Omit<FieldBase, 'required'>;
-export type RowAdmin = Omit<Admin, 'description'>;
+export type GroupFieldClient = {
+    admin?: {
+        components?: {
+            Label?: MappedComponent;
+        } & AdminClient['components'];
+    } & AdminClient & Pick<GroupField['admin'], 'hideGutter'>;
+    fields: ClientField[];
+} & Omit<FieldBaseClient, 'required'> & Pick<GroupField, 'interfaceName' | 'type'>;
 export type RowField = {
-    admin?: RowAdmin;
+    admin?: Omit<Admin, 'description'>;
     fields: Field[];
     type: 'row';
 } & Omit<FieldBase, 'admin' | 'label' | 'name' | 'validate'>;
+export type RowFieldClient = {
+    admin?: Omit<AdminClient, 'description'>;
+    fields: ClientField[];
+} & Omit<FieldBaseClient, 'admin' | 'label' | 'name' | 'validate'> & Pick<RowField, 'type'>;
 export type CollapsibleField = {
     fields: Field[];
     type: 'collapsible';
 } & ({
     admin: {
         components: {
+            Label?: LabelComponent;
             RowLabel: RowLabelComponent;
         } & Admin['components'];
         initCollapsed?: boolean;
@@ -371,11 +513,29 @@ export type CollapsibleField = {
     label?: Required<FieldBase['label']>;
 } | {
     admin?: {
+        components?: {
+            Label?: LabelComponent;
+        } & Admin['components'];
         initCollapsed?: boolean;
     } & Admin;
     label: Required<FieldBase['label']>;
 }) & Omit<FieldBase, 'label' | 'name' | 'validate'>;
-export type TabsAdmin = Omit<Admin, 'description'>;
+export type CollapsibleFieldClient = {
+    fields: ClientField[];
+} & ({
+    admin: {
+        components: {
+            RowLabel: MappedComponent;
+        } & AdminClient['components'];
+        initCollapsed?: boolean;
+    } & AdminClient;
+    label?: Required<FieldBaseClient['label']>;
+} | {
+    admin?: {
+        initCollapsed?: boolean;
+    } & AdminClient;
+    label: Required<FieldBaseClient['label']>;
+}) & Omit<FieldBaseClient, 'label' | 'name' | 'validate'> & Pick<CollapsibleField, 'type'>;
 type TabBase = {
     description?: Description;
     fields: Field[];
@@ -405,14 +565,19 @@ export type UnnamedTab = {
 } & Omit<TabBase, 'name'>;
 export type Tab = NamedTab | UnnamedTab;
 export type TabsField = {
-    admin?: TabsAdmin;
+    admin?: Omit<Admin, 'description'>;
     tabs: Tab[];
     type: 'tabs';
 } & Omit<FieldBase, 'admin' | 'localized' | 'name' | 'saveToJWT'>;
+export type TabsFieldClient = {
+    admin?: Omit<AdminClient, 'description'>;
+    tabs: ClientTab[];
+} & Omit<FieldBaseClient, 'admin' | 'localized' | 'name' | 'saveToJWT'> & Pick<TabsField, 'type'>;
 export type TabAsField = {
     name?: string;
     type: 'tab';
 } & Tab;
+export type TabAsFieldClient = ClientTab & Pick<TabAsField, 'name' | 'type'>;
 export type UIField = {
     admin: {
         components?: {
@@ -421,8 +586,8 @@ export type UIField = {
             /**
              * The Filter component has to be a client component
              */
-            Filter?: React.ComponentType<any>;
-        };
+            Filter?: PayloadComponent;
+        } & Admin['components'];
         condition?: Condition;
         /** Extension point to add your custom data. Available in server and client. */
         custom?: Record<string, any>;
@@ -441,12 +606,23 @@ export type UIField = {
     name: string;
     type: 'ui';
 };
+export type UIFieldClient = {
+    _isPresentational?: true;
+    admin: DeepUndefinable<FieldBaseClient['admin']> & {
+        components?: {
+            Cell?: MappedComponent;
+            Field: MappedComponent;
+            Filter?: MappedComponent;
+        } & AdminClient['components'];
+    } & Pick<UIField['admin'], 'custom' | 'disableBulkEdit' | 'disableListColumn' | 'position' | 'width'>;
+} & Omit<DeepUndefinable<FieldBaseClient>, '_isPresentational' | 'admin'> & // still include FieldBaseClient (even if it's undefinable) so that we don't need constant type checks (e.g. if('xy' in field))
+Pick<UIField, 'label' | 'name' | 'type'>;
 export type UploadField = {
     admin?: {
         components?: {
             Error?: ErrorComponent;
             Label?: LabelComponent;
-        };
+        } & Admin['components'];
     };
     displayPreview?: boolean;
     filterOptions?: FilterOptions;
@@ -460,30 +636,50 @@ export type UploadField = {
     type: 'upload';
     validate?: Validate<unknown, unknown, unknown, UploadField>;
 } & FieldBase;
-type CodeAdmin = {
-    components?: {
-        Error?: ErrorComponent;
-        Label?: LabelComponent;
+export type UploadFieldClient = {
+    admin?: {
+        components?: {
+            Error?: MappedComponent;
+            Label?: MappedComponent;
+        } & AdminClient['components'];
     };
-    editorOptions?: EditorProps['options'];
-    language?: string;
-} & Admin;
+} & FieldBaseClient & Pick<UploadField, 'displayPreview' | 'maxDepth' | 'relationTo' | 'type'>;
 export type CodeField = {
-    admin?: CodeAdmin;
+    admin?: {
+        components?: {
+            Error?: ErrorComponent;
+            Label?: LabelComponent;
+            afterInput?: CustomComponent[];
+            beforeInput?: CustomComponent[];
+        } & Admin['components'];
+        editorOptions?: EditorProps['options'];
+        language?: string;
+    } & Admin;
     maxLength?: number;
     minLength?: number;
     type: 'code';
     validate?: Validate<string, unknown, unknown, CodeField>;
 } & Omit<FieldBase, 'admin'>;
-type JSONAdmin = {
-    components?: {
-        Error?: ErrorComponent;
-        Label?: LabelComponent;
-    };
-    editorOptions?: EditorProps['options'];
-} & Admin;
+export type CodeFieldClient = {
+    admin?: {
+        components?: {
+            Error?: MappedComponent;
+            Label?: MappedComponent;
+            afterInput?: MappedComponent[];
+            beforeInput?: MappedComponent[];
+        } & AdminClient['components'];
+    } & AdminClient & Pick<CodeField['admin'], 'editorOptions' | 'language'>;
+} & Omit<FieldBaseClient, 'admin'> & Pick<CodeField, 'maxLength' | 'minLength' | 'type'>;
 export type JSONField = {
-    admin?: JSONAdmin;
+    admin?: {
+        components?: {
+            Error?: ErrorComponent;
+            Label?: LabelComponent;
+            afterInput?: CustomComponent[];
+            beforeInput?: CustomComponent[];
+        } & Admin['components'];
+        editorOptions?: EditorProps['options'];
+    } & Admin;
     jsonSchema?: {
         fileMatch: string[];
         schema: JSONSchema4;
@@ -492,12 +688,24 @@ export type JSONField = {
     type: 'json';
     validate?: Validate<Record<string, unknown>, unknown, unknown, JSONField>;
 } & Omit<FieldBase, 'admin'>;
+export type JSONFieldClient = {
+    admin?: {
+        components?: {
+            Error?: MappedComponent;
+            Label?: MappedComponent;
+            afterInput?: MappedComponent[];
+            beforeInput?: MappedComponent[];
+        } & AdminClient['components'];
+    } & AdminClient & Pick<JSONField['admin'], 'editorOptions'>;
+} & Omit<FieldBaseClient, 'admin'> & Pick<JSONField, 'jsonSchema' | 'type'>;
 export type SelectField = {
     admin?: {
         components?: {
             Error?: ErrorComponent;
             Label?: LabelComponent;
-        };
+            afterInput?: CustomComponent[];
+            beforeInput?: CustomComponent[];
+        } & Admin['components'];
         isClearable?: boolean;
         isSortable?: boolean;
     } & Admin;
@@ -514,6 +722,16 @@ export type SelectField = {
     type: 'select';
     validate?: Validate<string, unknown, unknown, SelectField>;
 } & FieldBase;
+export type SelectFieldClient = {
+    admin?: {
+        components?: {
+            Error?: MappedComponent;
+            Label?: MappedComponent;
+            afterInput?: MappedComponent[];
+            beforeInput?: MappedComponent[];
+        } & AdminClient['components'];
+    } & AdminClient & Pick<SelectField['admin'], 'isClearable' | 'isSortable'>;
+} & FieldBaseClient & Pick<SelectField, 'hasMany' | 'options' | 'type'>;
 type SharedRelationshipProperties = {
     filterOptions?: FilterOptions;
     hasMany?: boolean;
@@ -550,14 +768,21 @@ type SharedRelationshipProperties = {
     min?: undefined;
     minRows?: undefined;
 }) & FieldBase;
+type SharedRelationshipPropertiesClient = FieldBaseClient & Pick<SharedRelationshipProperties, 'hasMany' | 'max' | 'maxDepth' | 'maxRows' | 'min' | 'minRows' | 'type'>;
 type RelationshipAdmin = {
     allowCreate?: boolean;
     components?: {
         Error?: ErrorComponent;
         Label?: LabelComponent;
-    };
+    } & Admin['components'];
     isSortable?: boolean;
 } & Admin;
+type RelationshipAdminClient = {
+    components?: {
+        Error?: MappedComponent;
+        Label?: MappedComponent;
+    } & AdminClient['components'];
+} & AdminClient & Pick<RelationshipAdmin, 'allowCreate' | 'isSortable'>;
 export type PolymorphicRelationshipField = {
     admin?: {
         sortOptions?: {
@@ -566,27 +791,36 @@ export type PolymorphicRelationshipField = {
     } & RelationshipAdmin;
     relationTo: CollectionSlug[];
 } & SharedRelationshipProperties;
+export type PolymorphicRelationshipFieldClient = {
+    admin?: {
+        sortOptions?: Pick<PolymorphicRelationshipField['admin'], 'sortOptions'>;
+    } & RelationshipAdminClient;
+} & Pick<PolymorphicRelationshipField, 'relationTo'> & SharedRelationshipPropertiesClient;
 export type SingleRelationshipField = {
     admin?: {
         sortOptions?: string;
     } & RelationshipAdmin;
     relationTo: CollectionSlug;
 } & SharedRelationshipProperties;
+export type SingleRelationshipFieldClient = {
+    admin?: Pick<SingleRelationshipField['admin'], 'sortOptions'> & RelationshipAdminClient;
+} & Pick<SingleRelationshipField, 'relationTo'> & SharedRelationshipPropertiesClient;
 export type RelationshipField = PolymorphicRelationshipField | SingleRelationshipField;
+export type RelationshipFieldClient = PolymorphicRelationshipFieldClient;
 export type ValueWithRelation = {
     relationTo: CollectionSlug;
     value: number | string;
 };
 export declare function valueIsValueWithRelation(value: unknown): value is ValueWithRelation;
 export type RelationshipValue = (number | string)[] | ValueWithRelation | ValueWithRelation[] | (number | string);
-export type RichTextField<Value extends object = any, AdapterProps = any, ExtraProperties = object> = {
+export type RichTextField<TValue extends object = any, TAdapterProps = any, TExtraProperties = object> = {
     admin?: {
         components?: {
             Error?: ErrorComponent;
             Label?: LabelComponent;
-        };
+        } & Admin['components'];
     } & Admin;
-    editor?: RichTextAdapter<Value, AdapterProps, AdapterProps> | RichTextAdapterProvider<Value, AdapterProps, AdapterProps>;
+    editor?: RichTextAdapter<TValue, TAdapterProps, TExtraProperties> | RichTextAdapterProvider<TValue, TAdapterProps, TExtraProperties>;
     /**
      * Sets a maximum population depth for this field, regardless of the remaining depth when this field is reached.
      *
@@ -594,10 +828,21 @@ export type RichTextField<Value extends object = any, AdapterProps = any, ExtraP
      */
     maxDepth?: number;
     type: 'richText';
-} & ExtraProperties & FieldBase;
+} & FieldBase & TExtraProperties;
+export type RichTextFieldClient<TValue extends object = any, TAdapterProps = any, TExtraProperties = object> = {
+    admin?: {
+        components?: {
+            Error?: MappedComponent;
+            Label?: MappedComponent;
+        } & AdminClient['components'];
+    } & AdminClient;
+    richTextComponentMap?: Map<string, any>;
+} & FieldBaseClient & Pick<RichTextField<TValue, TAdapterProps, TExtraProperties>, 'maxDepth' | 'type'> & TExtraProperties;
 export type ArrayField = {
     admin?: {
         components?: {
+            Error?: ErrorComponent;
+            Label?: LabelComponent;
             RowLabel?: RowLabelComponent;
         } & Admin['components'];
         initCollapsed?: boolean;
@@ -624,12 +869,23 @@ export type ArrayField = {
     type: 'array';
     validate?: Validate<unknown[], unknown, unknown, ArrayField>;
 } & FieldBase;
+export type ArrayFieldClient = {
+    admin?: {
+        components?: {
+            Error?: MappedComponent;
+            Label?: MappedComponent;
+            RowLabel?: MappedComponent;
+        } & AdminClient['components'];
+    } & AdminClient & Pick<ArrayField['admin'], 'initCollapsed' | 'isSortable'>;
+    fields: ClientField[];
+    labels?: LabelsClient;
+} & FieldBaseClient & Pick<ArrayField, 'interfaceName' | 'maxRows' | 'minRows' | 'type'>;
 export type RadioField = {
     admin?: {
         components?: {
             Error?: ErrorComponent;
             Label?: LabelComponent;
-        };
+        } & Admin['components'];
         layout?: 'horizontal' | 'vertical';
     } & Admin;
     /**
@@ -644,10 +900,23 @@ export type RadioField = {
     type: 'radio';
     validate?: Validate<string, unknown, unknown, RadioField>;
 } & FieldBase;
+export type RadioFieldClient = {
+    admin?: {
+        components?: {
+            Error?: MappedComponent;
+            Label?: MappedComponent;
+        } & AdminClient['components'];
+    } & AdminClient & Pick<RadioField['admin'], 'layout'>;
+} & FieldBaseClient & Pick<RadioField, 'options' | 'type'>;
 export type Block = {
+    /**
+     * Do not set this property manually. This is set to true during sanitization, to avoid
+     * sanitizing the same block multiple times.
+     */
+    _sanitized?: boolean;
     admin?: {
         components?: {
-            Label?: React.FC<{
+            Label?: PayloadComponent<never, {
                 blockKind: 'block' | 'lexicalBlock' | 'lexicalInlineBlock' | string;
                 /**
                  * May contain the formData
@@ -681,8 +950,20 @@ export type Block = {
     labels?: Labels;
     slug: string;
 };
+export type ClientBlock = {
+    admin?: {
+        components?: {
+            Label?: MappedComponent;
+        };
+    } & Pick<Block['admin'], 'custom'>;
+    fields: ClientField[];
+    labels?: LabelsClient;
+} & Pick<Block, 'imageAltText' | 'imageURL' | 'slug'>;
 export type BlockField = {
     admin?: {
+        components?: {
+            Error?: ErrorComponent;
+        } & Admin['components'];
         initCollapsed?: boolean;
         /**
          * Disable drag and drop sorting
@@ -697,32 +978,80 @@ export type BlockField = {
     type: 'blocks';
     validate?: Validate<string, unknown, unknown, BlockField>;
 } & FieldBase;
+export type BlockFieldClient = {
+    admin?: {
+        components?: {
+            Error?: MappedComponent;
+        } & AdminClient['components'];
+    } & AdminClient & Pick<BlockField['admin'], 'initCollapsed' | 'isSortable'>;
+    blocks: ClientBlock[];
+    labels?: LabelsClient;
+} & FieldBaseClient & Pick<BlockField, 'maxRows' | 'minRows' | 'type'>;
 export type PointField = {
+    admin?: {
+        components?: {
+            Error?: ErrorComponent;
+            Label?: LabelComponent;
+            afterInput?: CustomComponent[];
+            beforeInput?: CustomComponent[];
+        } & Admin['components'];
+        placeholder?: Record<string, string> | string;
+        step?: number;
+    } & Admin;
     type: 'point';
     validate?: Validate<unknown, unknown, unknown, PointField>;
 } & FieldBase;
+export type PointFieldClient = {
+    admin?: {
+        components?: {
+            Error?: MappedComponent;
+            Label?: MappedComponent;
+            afterInput?: MappedComponent[];
+            beforeInput?: MappedComponent[];
+        } & AdminClient['components'];
+    } & AdminClient & Pick<PointField['admin'], 'placeholder' | 'step'>;
+} & FieldBaseClient & Pick<PointField, 'type'>;
 export type Field = ArrayField | BlockField | CheckboxField | CodeField | CollapsibleField | DateField | EmailField | GroupField | JSONField | NumberField | PointField | RadioField | RelationshipField | RichTextField | RowField | SelectField | TabsField | TextField | TextareaField | UIField | UploadField;
+export type ClientField = ArrayFieldClient | BlockFieldClient | CheckboxFieldClient | CodeFieldClient | CollapsibleFieldClient | DateFieldClient | EmailFieldClient | GroupFieldClient | JSONFieldClient | NumberFieldClient | PointFieldClient | RadioFieldClient | RelationshipFieldClient | RichTextFieldClient | RowFieldClient | SelectFieldClient | TabsFieldClient | TextFieldClient | TextareaFieldClient | UIFieldClient | UploadFieldClient;
+type ExtractFieldTypes<T> = T extends {
+    type: infer U;
+} ? U : never;
+export type FieldTypes = ExtractFieldTypes<Field>;
 export type FieldAffectingData = ArrayField | BlockField | CheckboxField | CodeField | DateField | EmailField | GroupField | JSONField | NumberField | PointField | RadioField | RelationshipField | RichTextField | SelectField | TabAsField | TextField | TextareaField | UploadField;
+export type FieldAffectingDataClient = ArrayFieldClient | BlockFieldClient | CheckboxFieldClient | CodeFieldClient | DateFieldClient | EmailFieldClient | GroupFieldClient | JSONFieldClient | NumberFieldClient | PointFieldClient | RadioFieldClient | RelationshipFieldClient | RichTextFieldClient | SelectFieldClient | TabAsFieldClient | TextFieldClient | TextareaFieldClient | UploadFieldClient;
 export type NonPresentationalField = ArrayField | BlockField | CheckboxField | CodeField | CollapsibleField | DateField | EmailField | GroupField | JSONField | NumberField | PointField | RadioField | RelationshipField | RichTextField | RowField | SelectField | TabsField | TextField | TextareaField | UploadField;
+export type NonPresentationalFieldClient = ArrayFieldClient | BlockFieldClient | CheckboxFieldClient | CodeFieldClient | CollapsibleFieldClient | DateFieldClient | EmailFieldClient | GroupFieldClient | JSONFieldClient | NumberFieldClient | PointFieldClient | RadioFieldClient | RelationshipFieldClient | RichTextFieldClient | RowFieldClient | SelectFieldClient | TabsFieldClient | TextFieldClient | TextareaFieldClient | UploadFieldClient;
 export type FieldWithPath = {
     path?: string;
 } & Field;
+export type FieldWithPathClient = {
+    path?: string;
+} & ClientField;
 export type FieldWithSubFields = ArrayField | CollapsibleField | GroupField | RowField;
+export type FieldWithSubFieldsClient = ArrayFieldClient | CollapsibleFieldClient | GroupFieldClient | RowFieldClient;
 export type FieldPresentationalOnly = UIField;
+export type FieldPresentationalOnlyClient = UIFieldClient;
 export type FieldWithMany = RelationshipField | SelectField;
+export type FieldWithManyClient = RelationshipFieldClient | SelectFieldClient;
 export type FieldWithMaxDepth = RelationshipField | UploadField;
-export declare function fieldHasSubFields(field: ClientFieldConfig | Field): field is FieldWithSubFields;
-export declare function fieldIsArrayType(field: Field): field is ArrayField;
-export declare function fieldIsBlockType(field: Field): field is BlockField;
-export declare function fieldIsGroupType(field: Field): field is GroupField;
+export type FieldWithMaxDepthClient = RelationshipFieldClient | UploadFieldClient;
+export declare function fieldHasSubFields<T extends ClientField | Field>(field: T): field is T & (T extends ClientField ? FieldWithSubFieldsClient : FieldWithSubFields);
+export declare function fieldIsArrayType<T extends ClientField | Field>(field: T): field is T & (T extends ClientField ? ArrayFieldClient : ArrayField);
+export declare function fieldIsBlockType<T extends ClientField | Field>(field: T): field is T & (T extends ClientField ? BlockFieldClient : BlockField);
+export declare function fieldIsGroupType<T extends ClientField | Field>(field: T): field is T & (T extends ClientField ? GroupFieldClient : GroupField);
 export declare function optionIsObject(option: Option): option is OptionObject;
 export declare function optionsAreObjects(options: Option[]): options is OptionObject[];
 export declare function optionIsValue(option: Option): option is string;
-export declare function fieldSupportsMany(field: Field): field is FieldWithMany;
-export declare function fieldHasMaxDepth(field: Field): field is FieldWithMaxDepth;
-export declare function fieldIsPresentationalOnly(field: ClientFieldConfig | Field | TabAsField): field is UIField;
-export declare function fieldAffectsData(field: ClientFieldConfig | Field | TabAsField): field is FieldAffectingData;
-export declare function tabHasName(tab: Tab): tab is NamedTab;
+export declare function fieldSupportsMany<T extends ClientField | Field>(field: T): field is T & (T extends ClientField ? FieldWithManyClient : FieldWithMany);
+export declare function fieldHasMaxDepth<T extends ClientField | Field>(field: T): field is T & (T extends ClientField ? FieldWithMaxDepthClient : FieldWithMaxDepth);
+export declare function fieldIsPresentationalOnly<T extends ClientField | Field | TabAsField | TabAsFieldClient>(field: T): field is T & (T extends ClientField | TabAsFieldClient ? UIFieldClient : UIField);
+export declare function fieldIsSidebar<T extends ClientField | Field | TabAsField | TabAsFieldClient>(field: T): field is {
+    admin: {
+        position: 'sidebar';
+    };
+} & T;
+export declare function fieldAffectsData<T extends ClientField | Field | TabAsField | TabAsFieldClient>(field: T): field is T & (T extends ClientField | TabAsFieldClient ? FieldAffectingDataClient : FieldAffectingData);
+export declare function tabHasName<T extends ClientTab | Tab>(tab: T): tab is NamedTab & T;
 export declare function fieldIsLocalized(field: Field | Tab): boolean;
 export type HookName = 'afterChange' | 'afterRead' | 'beforeChange' | 'beforeRead' | 'beforeValidate';
 export {};