import Collection, { type Fieldnames } from "./collection.js";
import type Context from "../context.js";
import type { AttachmentOptions } from "./item-list.js";
import type { FieldsetInput, FieldsetOutput } from "./fieldset.js";
import { CollectionItemBody } from "./collection-item-body.js";
import type { ItemListResult } from "./item-list-result.js";
export type ItemMetadata = {
    modified_at: number;
    created_at: number;
    created_by: string | null;
};
export type SerializedItem = ReturnType<CollectionItem["serialize"]>;
export type SerializedItemBody = ReturnType<CollectionItem["serializeBody"]>;
export default class CollectionItem<T extends Collection = any> {
    collection: T;
    body: CollectionItemBody;
    _metadata: ItemMetadata;
    id: string;
    fields_with_attachments: string[];
    attachments: Record<string, CollectionItem>;
    private attachments_loaded;
    private save_mode;
    original_body: CollectionItemBody;
    has_been_replaced: boolean;
    parent_list: ItemListResult<T> | null;
    constructor(collection: T, body: CollectionItemBody, _metadata?: ItemMetadata, id?: string, attachments?: Record<string, CollectionItem>);
    /** Checks whether or not it is allowed to save the given item to the DB using given context */
    private canSave;
    private canDelete;
    throwIfInvalid(action: "create" | "edit", context: Context, replace_mode: boolean): Promise<void>;
    /** Save the item to the database */
    save(context: Context, is_http_api_request?: boolean): Promise<this>;
    gatherDefaultValues(context: Context): Promise<void>;
    /** sets a value */
    set<FieldName extends Fieldnames<T>>(field_name: FieldName, field_value: FieldsetInput<T["fields"]>[FieldName], blessed_symbol?: symbol): CollectionItem<T>;
    setMultiple(values: Partial<FieldsetInput<T["fields"]>>): this;
    /** Ensures that every field value is considered. This is useful for forms,
        where you can create a form with all fields for a collection, then add a
        new field to the collection and want to be notified by typescript about
        all forms that need to be updated */
    setMultipleExtraSafe(values: FieldsetInput<T["fields"]>): this;
    replace(values: Partial<FieldsetInput<T["fields"]>>): void;
    get<FieldName extends Fieldnames<T>>(field_name: FieldName, include_raw?: boolean): FieldsetOutput<T["fields"]>[FieldName];
    /**
     * if has decoded value it return this otherwise it decode it in first place
     * @param field_name name of field we want to get decoded
     * @param context
     */
    getDecoded<FieldName extends Fieldnames<T>>(field_name: FieldName, context: Context): Promise<unknown>;
    getDecodedBody(context: Context, is_http?: boolean): Promise<Partial<FieldsetOutput<any>>>;
    remove(context: Context): Promise<void>;
    delete(context: Context): Promise<void>;
    serialize(): {
        items: any[];
        attachments: Record<string, any>;
        fields_with_attachments: string[];
    };
    decode(context: Context, is_http_api_request?: boolean): Promise<CollectionItem<T>>;
    serializeBody(): {
        id: string;
    } & FieldsetOutput<T["fields"]>;
    safeLoadAttachments(context: Context, attachment_options: unknown): Promise<this>;
    loadAttachments(context: Context, attachment_options?: AttachmentOptions<T>): Promise<this>;
    static fromSerialized<T extends Collection>(collection: T, data: {
        id: string;
        _metadata: ItemMetadata;
    }, attachments: {
        [id: string]: any;
    }): CollectionItem<T>;
    fetchAs(context: Context): Promise<CollectionItem<T>>;
    getAttachmentIDs<FieldName extends keyof T["fields"]>(field_name: FieldName): string[];
    getAttachments<FieldName extends keyof T["fields"]>(field_name: FieldName): CollectionItem[];
    setParentList(list: ItemListResult<T>): void;
    getBlessing<FieldName extends keyof T["fields"]>(field_name: FieldName): symbol | null;
    summarizeChanges(context: Context): Promise<Record<keyof T["fields"], {
        was: unknown;
        is: unknown;
    }>>;
}