import { HTMLAttributes, ReactElement, ReactNode } from 'react';
export type FormFieldValue = string | number | boolean | null | readonly FormFieldValue[] | {
    [key: string]: FormFieldValue | undefined;
};
type BasicFormField<Value, Options> = {
    kind: 'form';
    Input(props: {
        value: Value;
        onChange(value: Value): void;
        autoFocus: boolean;
        /**
         * This will be true when validate has returned false and the user has attempted to close the form
         * or when the form is open and they attempt to save the item
         */
        forceValidation: boolean;
    }): ReactElement | null;
    /**
     * The options are config about the field that are available on the
     * preview props when rendering the toolbar and preview component
     */
    options: Options;
    defaultValue: Value;
    /**
     * validate will be called in two cases:
     * - on the client in the editor when a user is changing the value.
     *   Returning `false` will block closing the form
     *   and saving the item.
     * - on the server when a change is received before allowing it to be saved
     *   if `true` is returned
     * @param value The value of the form field. You should NOT trust
     * this value to be of the correct type because it could come from
     * a potentially malicious client
     */
    validate(value: unknown): boolean;
};
export type FormField<Value, Options> = BasicFormField<Value, Options> | FormFieldWithFile<Value, Options, any>;
export type FormFieldWithFile<Value, Options, DataInReader> = FormFieldWithFileRequiringContentsForReader<Value, Options, DataInReader> | FormFieldWithFileNotRequiringContentsForReader<Value, Options, DataInReader>;
type FormFieldWithFileRequiringContentsForReader<Value, Options, DataInReader> = BasicFormField<Value, Options> & {
    serializeToFile: (BaseSerializeToSingleFile<Value> & {
        reader: {
            requiresContentInReader: true;
            parseToReader(data: {
                content: Uint8Array | undefined;
                value: unknown;
                suggestedFilenamePrefix: string | undefined;
            }): DataInReader;
        };
    }) | (BaseSerializeToFiles<Value> & {
        reader: {
            requiresContentInReader: true;
            parseToReader(data: {
                value: unknown;
                primary: Uint8Array | undefined;
                other: {
                    [key: string]: Uint8Array;
                };
            }): DataInReader;
        };
    });
};
type FormFieldWithFileNotRequiringContentsForReader<Value, Options, DataInReader> = BasicFormField<Value, Options> & {
    serializeToFile: (BaseSerializeToSingleFile<Value> & {
        reader: {
            requiresContentInReader: false;
            parseToReader(data: {
                value: unknown;
                suggestedFilenamePrefix: string | undefined;
            }): DataInReader;
        };
    }) | (BaseSerializeToFiles<Value> & {
        reader: {
            requiresContentInReader: false;
            parseToReader(data: {
                value: unknown;
            }): DataInReader;
        };
    });
};
type BaseSerializeToSingleFile<Value> = {
    kind: 'asset';
    filename(value: unknown, suggestedFilenamePrefix: string | undefined): string | undefined;
    serialize(value: Value, suggestedFilenamePrefix: string | undefined): {
        value: unknown;
    } & ({
        content: undefined;
    } | {
        content: Uint8Array;
        filename: string;
    });
    parse(data: {
        content: Uint8Array | undefined;
        value: unknown;
        suggestedFilenamePrefix: string | undefined;
    }): Value;
};
type BaseSerializeToFiles<Value> = {
    kind: 'multi';
    primaryExtension: string;
    files(value: unknown): string[];
    serialize(value: Value): Promise<{
        value: unknown;
        primary: Uint8Array | undefined;
        other: {
            [key: string]: Uint8Array;
        };
    }>;
    parse(data: {
        value: unknown;
        primary: Uint8Array | undefined;
        other: {
            [key: string]: Uint8Array;
        };
    }): Value;
};
export type DocumentNode = DocumentElement | DocumentText;
export type DocumentElement = {
    children: DocumentNode[];
    [key: string]: unknown;
};
export type DocumentText = {
    text: string;
    [key: string]: unknown;
};
type InlineMarksConfig = 'inherit' | {
    bold?: 'inherit';
    code?: 'inherit';
    italic?: 'inherit';
    strikethrough?: 'inherit';
    underline?: 'inherit';
    keyboard?: 'inherit';
    subscript?: 'inherit';
    superscript?: 'inherit';
};
type BlockFormattingConfig = {
    alignment?: 'inherit';
    blockTypes?: 'inherit';
    headingLevels?: 'inherit' | (1 | 2 | 3 | 4 | 5 | 6)[];
    inlineMarks?: InlineMarksConfig;
    listTypes?: 'inherit';
    softBreaks?: 'inherit';
};
export type ChildField = {
    kind: 'child';
    options: {
        kind: 'block';
        placeholder: string;
        formatting?: BlockFormattingConfig;
        dividers?: 'inherit';
        links?: 'inherit';
        relationships?: 'inherit';
    } | {
        kind: 'inline';
        placeholder: string;
        formatting?: {
            inlineMarks?: InlineMarksConfig;
            softBreaks?: 'inherit';
        };
        links?: 'inherit';
        relationships?: 'inherit';
    };
};
export type ArrayField<ElementField extends ComponentSchema> = {
    kind: 'array';
    element: ElementField;
    label: string;
    itemLabel?(props: unknown): string;
    asChildTag?: string;
};
export type RelationshipField<Many extends boolean> = {
    kind: 'relationship';
    listKey: string;
    selection: string | undefined;
    label: string;
    many: Many;
};
export interface ObjectField<Fields extends Record<string, ComponentSchema> = Record<string, ComponentSchema>> {
    kind: 'object';
    fields: Fields;
}
export type ConditionalField<DiscriminantField extends FormField<string | boolean, any>, ConditionalValues extends {
    [Key in `${DiscriminantField['defaultValue']}`]: ComponentSchema;
}> = {
    kind: 'conditional';
    discriminant: DiscriminantField;
    values: ConditionalValues;
};
type ArrayFieldInComponentSchema = {
    kind: 'array';
    element: ComponentSchema;
    label: string;
    itemLabel?(props: unknown): string;
    asChildTag?: string;
};
export type ComponentSchema = ChildField | FormField<any, any> | ObjectField | ConditionalField<FormField<any, any>, {
    [key: string]: ComponentSchema;
}> | RelationshipField<boolean> | ArrayFieldInComponentSchema;
export declare const fields: {
    text({ label, defaultValue, validation: { length: { max, min } }, description, multiline, }: {
        label: string;
        defaultValue?: string | undefined;
        description?: string | undefined;
        validation?: {
            length?: {
                min?: number | undefined;
                max?: number | undefined;
            } | undefined;
        } | undefined;
        multiline?: boolean | undefined;
    }): BasicFormField<string, undefined>;
    integer({ label, defaultValue, }: {
        label: string;
        defaultValue?: number | undefined;
    }): BasicFormField<number, undefined>;
    url({ label, defaultValue, }: {
        label: string;
        defaultValue?: string | undefined;
    }): BasicFormField<string, undefined>;
    select<Option extends {
        label: string;
        value: string;
    }>({ label, options, defaultValue, }: {
        label: string;
        options: readonly Option[];
        defaultValue: Option["value"];
    }): BasicFormField<Option["value"], readonly Option[]>;
    multiselect<Option_1 extends {
        label: string;
        value: string;
    }>({ label, options, defaultValue, }: {
        label: string;
        options: readonly Option_1[];
        defaultValue?: readonly Option_1["value"][] | undefined;
    }): BasicFormField<readonly Option_1["value"][], readonly Option_1[]>;
    checkbox({ label, defaultValue, }: {
        label: string;
        defaultValue?: boolean | undefined;
    }): BasicFormField<boolean, undefined>;
    image({ label, }: {
        label: string;
    }): FormFieldWithFileNotRequiringContentsForReader<{
        kind: 'uploaded';
        data: Uint8Array;
        extension: string;
        filename: string;
    } | {
        kind: 'none';
    }, undefined, string | null>;
    date({ label }: {
        label: string;
    }): BasicFormField<string | null, undefined>;
    empty(): BasicFormField<null, undefined>;
    child(options: {
        kind: 'block';
        placeholder: string;
        formatting?: BlockFormattingConfig | 'inherit';
        dividers?: 'inherit';
        links?: 'inherit';
        relationships?: 'inherit';
    } | {
        kind: 'inline';
        placeholder: string;
        formatting?: 'inherit' | {
            inlineMarks?: InlineMarksConfig;
            softBreaks?: 'inherit';
        };
        links?: 'inherit';
        relationships?: 'inherit';
    }): ChildField;
    object<Fields extends Record<string, ComponentSchema>>(fields: Fields): ObjectField<Fields>;
    conditional<DiscriminantField extends FormField<string | boolean, any>, ConditionalValues extends { [Key in `${DiscriminantField["defaultValue"]}`]: ComponentSchema; }>(discriminant: DiscriminantField, values: ConditionalValues): ConditionalField<DiscriminantField, ConditionalValues>;
    document({ label, componentBlocks, }: {
        label: string;
        componentBlocks?: Record<string, ComponentBlock<Record<string, ComponentSchema>>> | undefined;
    }): FormFieldWithFileRequiringContentsForReader<DocumentElement[], undefined, DocumentElement[]>;
    relationship<Many extends boolean | undefined = false>({ listKey, selection, label, many, }: {
        listKey: string;
        label: string;
        selection?: string | undefined;
    } & (Many extends false | undefined ? {
        many?: Many | undefined;
    } : {
        many: Many;
    })): RelationshipField<Many extends true ? true : false>;
    array<ElementField extends ComponentSchema>(element: ElementField, opts?: {
        label?: string | undefined;
        itemLabel?: ((props: GenericPreviewProps<ElementField, unknown>) => string) | undefined;
        asChildTag?: string | undefined;
    } | undefined): ArrayField<ElementField>;
};
export type ComponentBlock<Fields extends Record<string, ComponentSchema> = Record<string, ComponentSchema>> = {
    preview: (props: any) => ReactElement | null;
    schema: Fields;
    label: string;
} & ({
    chromeless: true;
    toolbar?: (props: {
        props: Record<string, any>;
        onRemove(): void;
    }) => ReactElement;
} | {
    chromeless?: false;
    toolbar?: (props: {
        props: Record<string, any>;
        onShowEditMode(): void;
        onRemove(): void;
        isValid: boolean;
    }) => ReactElement;
});
type ChildFieldPreviewProps<Schema extends ChildField, ChildFieldElement> = {
    readonly element: ChildFieldElement;
    readonly schema: Schema;
};
type FormFieldPreviewProps<Schema extends FormField<any, any>> = {
    readonly value: Schema['defaultValue'];
    onChange(value: Schema['defaultValue']): void;
    readonly options: Schema['options'];
    readonly schema: Schema;
};
type ObjectFieldPreviewProps<Schema extends ObjectField<any>, ChildFieldElement> = {
    readonly fields: {
        readonly [Key in keyof Schema['fields']]: GenericPreviewProps<Schema['fields'][Key], ChildFieldElement>;
    };
    onChange(value: {
        readonly [Key in keyof Schema['fields']]?: InitialOrUpdateValueFromComponentPropField<Schema['fields'][Key]>;
    }): void;
    readonly schema: Schema;
};
type ConditionalFieldPreviewProps<Schema extends ConditionalField<FormField<string | boolean, any>, any>, ChildFieldElement> = {
    readonly [Key in keyof Schema['values']]: {
        readonly discriminant: DiscriminantStringToDiscriminantValue<Schema['discriminant'], Key>;
        onChange<Discriminant extends Schema['discriminant']['defaultValue']>(discriminant: Discriminant, value?: InitialOrUpdateValueFromComponentPropField<Schema['values'][`${Discriminant}`]>): void;
        readonly options: Schema['discriminant']['options'];
        readonly value: GenericPreviewProps<Schema['values'][Key], ChildFieldElement>;
        readonly schema: Schema;
    };
}[keyof Schema['values']];
type RelationshipDataType<Many extends boolean> = Many extends true ? readonly HydratedRelationshipData[] : HydratedRelationshipData | null;
type RelationshipFieldPreviewProps<Schema extends RelationshipField<boolean>> = {
    readonly value: RelationshipDataType<Schema['many']>;
    onChange(relationshipData: RelationshipDataType<Schema['many']>): void;
    readonly schema: Schema;
};
type ArrayFieldPreviewProps<Schema extends ArrayField<ComponentSchema>, ChildFieldElement> = {
    readonly elements: readonly (GenericPreviewProps<Schema['element'], ChildFieldElement> & {
        readonly key: string;
    })[];
    readonly onChange: (value: readonly {
        key: string | undefined;
        value?: InitialOrUpdateValueFromComponentPropField<Schema['element']>;
    }[]) => void;
    readonly schema: Schema;
};
export type GenericPreviewProps<Schema extends ComponentSchema, ChildFieldElement> = Schema extends ChildField ? ChildFieldPreviewProps<Schema, ChildFieldElement> : Schema extends FormField<any, any> ? FormFieldPreviewProps<Schema> : Schema extends ObjectField<any> ? ObjectFieldPreviewProps<Schema, ChildFieldElement> : Schema extends ConditionalField<any, any> ? ConditionalFieldPreviewProps<Schema, ChildFieldElement> : Schema extends RelationshipField<any> ? RelationshipFieldPreviewProps<Schema> : Schema extends ArrayField<any> ? ArrayFieldPreviewProps<Schema, ChildFieldElement> : never;
export type PreviewProps<Schema extends ComponentSchema> = GenericPreviewProps<Schema, ReactNode>;
export type InitialOrUpdateValueFromComponentPropField<Schema extends ComponentSchema> = Schema extends ChildField ? undefined : Schema extends FormField<infer Value, any> ? Value | undefined : Schema extends ObjectField<infer Value> ? {
    readonly [Key in keyof Value]?: InitialOrUpdateValueFromComponentPropField<Value[Key]>;
} : Schema extends ConditionalField<infer DiscriminantField, infer Values> ? {
    readonly [Key in keyof Values]: {
        readonly discriminant: DiscriminantStringToDiscriminantValue<DiscriminantField, Key>;
        readonly value?: InitialOrUpdateValueFromComponentPropField<Values[Key]>;
    };
}[keyof Values] : Schema extends RelationshipField<infer Many> ? Many extends true ? readonly HydratedRelationshipData[] : HydratedRelationshipData | null : Schema extends ArrayField<infer ElementField> ? readonly {
    key: string | undefined;
    value?: InitialOrUpdateValueFromComponentPropField<ElementField>;
}[] : never;
type DiscriminantStringToDiscriminantValue<DiscriminantField extends FormField<any, any>, DiscriminantString extends PropertyKey> = DiscriminantField['defaultValue'] extends boolean ? 'true' extends DiscriminantString ? true : 'false' extends DiscriminantString ? false : never : DiscriminantString;
export type PreviewPropsForToolbar<Schema extends ComponentSchema> = GenericPreviewProps<Schema, undefined>;
export type HydratedRelationshipData = {
    id: string;
    label: string;
    data: Record<string, any>;
};
export type RelationshipData = {
    id: string;
    label: string | undefined;
    data: Record<string, any> | undefined;
};
export declare function component<Schema extends {
    [Key in any]: ComponentSchema;
}>(options: {
    /** The preview component shown in the editor */
    preview: (props: PreviewProps<ObjectField<Schema>>) => ReactElement | null;
    /** The schema for the props that the preview component, toolbar and rendered component will receive */
    schema: Schema;
    /** The label to show in the insert menu and chrome around the block if chromeless is false */
    label: string;
} & ({
    chromeless: true;
    toolbar?: (props: {
        props: PreviewPropsForToolbar<ObjectField<Schema>>;
        onRemove(): void;
    }) => ReactElement;
} | {
    chromeless?: false;
    toolbar?: (props: {
        props: PreviewPropsForToolbar<ObjectField<Schema>>;
        onShowEditMode(): void;
        onRemove(): void;
    }) => ReactElement;
})): ComponentBlock<Schema>;
export declare function NotEditable({ children, ...props }: HTMLAttributes<HTMLDivElement>): JSX.Element;
type Comp<Props> = (props: Props) => ReactElement | null;
export type ValueForComponentSchema<Schema extends ComponentSchema> = Schema extends ChildField ? null : Schema extends FormField<infer Value, any> ? Value : Schema extends ObjectField<infer Value> ? {
    readonly [Key in keyof Value]: ValueForComponentSchema<Value[Key]>;
} : Schema extends ConditionalField<infer DiscriminantField, infer Values> ? {
    readonly [Key in keyof Values]: {
        readonly discriminant: DiscriminantStringToDiscriminantValue<DiscriminantField, Key>;
        readonly value: ValueForComponentSchema<Values[Key]>;
    };
}[keyof Values] : Schema extends RelationshipField<infer Many> ? Many extends true ? readonly HydratedRelationshipData[] : HydratedRelationshipData | null : Schema extends ArrayField<infer ElementField> ? readonly ValueForComponentSchema<ElementField>[] : never;
export type ValueForReading<Schema extends ComponentSchema> = Schema extends ChildField ? null : Schema extends FormFieldWithFileRequiringContentsForReader<any, any, infer Value> ? () => Promise<Value> : Schema extends FormFieldWithFileNotRequiringContentsForReader<any, any, infer Value> ? Value : Schema extends BasicFormField<infer Value, any> ? Value : Schema extends ObjectField<infer Value> ? {
    readonly [Key in keyof Value]: ValueForReading<Value[Key]>;
} : Schema extends ConditionalField<infer DiscriminantField, infer Values> ? {
    readonly [Key in keyof Values]: {
        readonly discriminant: DiscriminantStringToDiscriminantValue<DiscriminantField, Key>;
        readonly value: ValueForReading<Values[Key]>;
    };
}[keyof Values] : Schema extends RelationshipField<infer Many> ? Many extends true ? readonly HydratedRelationshipData[] : HydratedRelationshipData | null : Schema extends ArrayField<infer ElementField> ? readonly ValueForReading<ElementField>[] : never;
export type InferRenderersForComponentBlocks<ComponentBlocks extends Record<string, ComponentBlock<any>>> = {
    [Key in keyof ComponentBlocks]: Comp<ValueForReading<ObjectField<ComponentBlocks[Key]['schema']>>>;
};
export {};