import { EntityRef, FieldValueMap, EntityType, ResolvedFieldGroup, FieldGroup, FieldDefinition, FieldValue, FieldType } from '@platform-modules/fields';
export { EntityRef, EntityType, FieldDefinition, FieldGroup, FieldValue, FieldValueMap, ResolvedFieldGroup } from '@platform-modules/fields';
import * as react from 'react';
import { ReactNode, ComponentType } from 'react';

interface FieldsClient {
    getEntityValues(ref: EntityRef, opts: {
        subType?: string;
    }): Promise<FieldValueMap>;
    setEntityValues(input: {
        ref: EntityRef;
        groupId: string;
        values: FieldValueMap;
    }): Promise<void>;
    resolveGroups(opts: {
        entityType: EntityType;
        subType?: string;
    }): Promise<ResolvedFieldGroup[]>;
    listGroups(opts: {
        entityType?: EntityType;
        subType?: string;
    }): Promise<ResolvedFieldGroup[]>;
    createGroup(g: FieldGroup): Promise<ResolvedFieldGroup>;
    updateGroup(id: string, patch: Partial<FieldGroup>): Promise<ResolvedFieldGroup>;
    deleteGroup(id: string): Promise<void>;
}

declare function FieldsProvider({ client, children }: {
    client: FieldsClient;
    children: ReactNode;
}): react.JSX.Element;
declare function useFieldsClient(): FieldsClient;

declare function useFieldValues(ref: EntityRef, opts?: {
    subType?: string;
    initialData?: FieldValueMap;
}): {
    values: FieldValueMap;
    loading: boolean;
    error: Error | null;
    reload: () => void;
};
declare function useEntityFields(ref: EntityRef, opts?: {
    subType?: string;
    initialData?: FieldValueMap;
}): {
    values: FieldValueMap;
    groups: ResolvedFieldGroup[];
    loading: boolean;
    error: Error | null;
    save: (groupId: string, nextValues: FieldValueMap) => Promise<void>;
    reload: () => void;
};
declare function useFieldGroupBuilder(entityType: EntityType, opts?: {
    subType?: string;
}): {
    groups: ResolvedFieldGroup[];
    loading: boolean;
    error: Error | null;
    create: (group: FieldGroup) => Promise<void>;
    update: (id: string, patch: Partial<FieldGroup>) => Promise<void>;
    remove: (id: string) => Promise<void>;
    reload: () => void;
};

interface FieldInputProps<F extends FieldDefinition = FieldDefinition> {
    field: F;
    value: FieldValue | undefined;
    onChange: (v: FieldValue | undefined) => void;
    error?: string;
    disabled?: boolean;
}
type FieldInputRegistry = {
    [T in FieldType]: ComponentType<FieldInputProps>;
};
declare const referenceInputs: FieldInputRegistry;

interface FieldValuesFormProps {
    groups: ResolvedFieldGroup[];
    initialValues?: Record<string, FieldValueMap>;
    onSubmit: (groups: {
        groupId: string;
        values: FieldValueMap;
    }[]) => void | Promise<void>;
    disabled?: boolean;
    errors?: Record<string, Record<string, string>>;
}
declare function FieldValuesForm({ groups, initialValues, onSubmit, disabled, errors, }: FieldValuesFormProps): react.JSX.Element;

interface FieldGroupEditorProps {
    entityType: EntityType;
    subType?: string;
}
declare function FieldGroupEditor({ entityType, subType }: FieldGroupEditorProps): react.JSX.Element;

export { FieldGroupEditor, type FieldInputProps, type FieldInputRegistry, FieldValuesForm, type FieldsClient, FieldsProvider, referenceInputs, useEntityFields, useFieldGroupBuilder, useFieldValues, useFieldsClient };