import type Koa from "koa";
import Router from "@koa/router";
import Emittery from "emittery";
import type { ActionName } from "../action.js";
import type { App } from "../app/app.js";
import type Context from "../context.js";
import type CalculatedField from "./calculated-field.js";
import CollectionItem from "./collection-item.js";
import { CollectionItemBody } from "./collection-item-body.js";
import type Field from "./field.js";
import type { FieldsetEncoded, FieldsetInput, FieldsetInputWithAllKeys, FieldsetOutput } from "./fieldset.js";
import ItemList, { type SortParams } from "./item-list.js";
import type Policy from "./policy.js";
import type SpecialFilter from "./special-filter.js";
import type { CollectionProperties } from "../schemas/generator.js";
export type CollectionEvent = "before:create" | "after:create" | "before:remove" | "after:remove" | "before:edit" | "after:edit";
export type CollectionCallback = ([context, item, event]: [
    Context,
    CollectionItem,
    CollectionEvent
]) => Promise<void>;
export type CollectionValidationResult = {
    error: string;
    fields: string[];
}[];
export type CollectionOutput<T extends Collection> = FieldsetOutput<T["fields"]>;
export type CollectionInput<T extends Collection> = FieldsetInput<T["fields"]>;
export type CollectionInputWithAllKeys<T extends Collection> = FieldsetInputWithAllKeys<T["fields"]>;
export type CollectionEncoded<T extends Collection> = FieldsetEncoded<T["fields"]>;
export type Fieldnames<T extends Collection> = keyof T["fields"] & string;
/** Creates a collection. All collections are automatically served via
 * the REST API, with permissions set by the Policies */
export default abstract class Collection {
    abstract fields: Record<string, Field<any>>;
    private emitter;
    /** the name of the collection, will be used as part of the URI in
     * the REST API */
    name: string;
    /** policies for this collection. Who can do what */
    policies: Partial<{
        [a in ActionName]: Policy;
    }>;
    /** The policy to use when deciding on an action not specified in
     * `policies` */
    defaultPolicy: Policy;
    /** The app this collection is tied to */
    app: App;
    /** Whether or not should be visible in docs */
    internal: boolean;
    named_filters: Record<string, SpecialFilter>;
    calculated_fields: Record<string, CalculatedField<unknown>>;
    /** initializes the fields @internal */
    initFieldDetails(): Promise<void>;
    suCreate(data: CollectionInput<this>): Promise<CollectionItem<this>>;
    /** the "unsafe" flavor of CRUD functions are meant for cases where you want
    to just get the errror message and parse it - for example, when you want to
    get a nice error that can be used to display errors in a form */
    suCreateUnsafe(data: Record<string, unknown>): Promise<CollectionItem<this>>;
    create(context: Context, data: CollectionInput<this>): Promise<CollectionItem<this>>;
    /** extra safe = ensures that ALL fields are present, even if optional (if
     empty, specify 'undefined') as value.  Useful for collection forms where
     you might add a collection field in the future and don't want to forget to
     handle it in the form, as well */
    createExtraSafe(context: Context, data: CollectionInputWithAllKeys<this>): Promise<CollectionItem<this>>;
    createUnsafe(context: Context, data: Record<string, unknown>): Promise<CollectionItem<this>>;
    /** Makes a new item object that can be saved later */
    make(input?: Partial<CollectionInput<this>>): CollectionItem<this>;
    suGetByID(id: string): Promise<CollectionItem<this>>;
    getByID(context: Context, id: string, give_descriptive_errors?: boolean): Promise<CollectionItem<this>>;
    suRemoveByID(id: string, wait_for_after_events?: boolean): Promise<void>;
    removeByID(context: Context, id: string, wait_for_after_events?: boolean): Promise<void>;
    /** Get a policy for given action, an inherited policy, or the default
     * policy, if no policy is specified for this action */
    getPolicy(action: ActionName): Policy;
    /** Initialize all the fields and filters
     * @internal
     */
    init(app: App, collection_name: string): Promise<void>;
    /** Whether or not any of the fields' behavior depends on the
     * current values of themselves or other fields
     *
     * @param action_name
     * the action for which to check @internal
     */
    isOldValueSensitive(action_name: ActionName): boolean;
    /** Return a named filter from the collection
     * @param filter_name the name of the filter
     */
    getNamedFilter(filter_name: string): SpecialFilter;
    suList(): ItemList<this>;
    list(context: Context): ItemList<this>;
    createFromDB(document: Record<string, unknown>): CollectionItem<this>;
    on(event_name: CollectionEvent, cb: CollectionCallback): Emittery.UnsubscribeFn;
    getRequiredFields(): Field<unknown>[];
    setPolicy(action: ActionName, policy: Policy): this;
    getRouter(): Router;
    clearListeners(): void;
    emit(event_name: string, event_data?: any): Promise<void>;
    validate(context: Context, new_body: CollectionItemBody<any>, old_body: CollectionItemBody<any>, action: "create" | "edit"): Promise<CollectionValidationResult>;
    static getFieldnames<C extends Collection>(collection: C): Array<keyof FieldsetInput<C["fields"]> & string>;
    upsert<C extends Collection, IdentityField extends keyof CollectionInput<C>>(this: C, context: Context, identify_by: IdentityField, entries: (CollectionInput<C> & {
        [key in IdentityField]: CollectionInput<C>[IdentityField];
    })[]): Promise<void>;
    hasFeed(): boolean;
    getFeedSize(_ctx: Koa.Context): Promise<number>;
    getFeedSortOrder(_ctx: Koa.Context): Promise<SortParams<this>>;
    getFeedItems(ctx: Koa.Context): Promise<CollectionItem<this>[]>;
    mapFieldsToFeed(): FieldEntryMapping<this>;
    getFeedTitle(ctx: Koa.Context): Promise<string>;
    getFeedItemData(ctx: Koa.Context, item: CollectionItem<this>): Promise<FeedEntryShape>;
    getFeed(ctx: Koa.Context): Promise<string>;
    static getOpenApiSubfieldsSchema(context: Context, fields: Record<string, Field<unknown>>): Promise<CollectionProperties>;
    getOpenApiSchema(context: Context): Promise<CollectionProperties>;
}
export type FieldToFeedMappingEntry<C extends Collection, T> = T | ((context: Koa.Context, item: CollectionItem<C>) => Promise<T>);
export type FeedEntryShape = {
    title: string;
    link: {
        rel?: string;
        type?: string;
        href: string;
    }[];
    author: string[];
    category?: string[];
    id: string;
    content: string;
    published: Date;
    updated: Date;
};
export type FieldEntryMapping<C extends Collection> = {
    [Property in keyof FeedEntryShape]: FieldToFeedMappingEntry<C, FeedEntryShape[Property]>;
};