import { Result } from "@webiny/feature/api";
import type { CmsDeleteEntryOptions, CmsEntry, CmsModel } from "../../../types/index.js";
import type { EntryNotAuthorizedError, EntryNotFoundError, EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
/**
 * DeleteEntry Use Case - Permanently deletes an entry from the database.
 * This is a hard delete that removes all traces of the entry.
 */
export interface IDeleteEntryUseCase {
    execute(model: CmsModel, id: string, options?: CmsDeleteEntryOptions): Promise<Result<void, UseCaseError>>;
}
export interface IDeleteEntryUseCaseErrors {
    notAuthorized: EntryNotAuthorizedError;
    notFound: EntryNotFoundError;
    storage: EntryPersistenceError;
}
type UseCaseError = IDeleteEntryUseCaseErrors[keyof IDeleteEntryUseCaseErrors];
/** Delete a content entry. */
export declare const DeleteEntryUseCase: import("@webiny/di").Abstraction<IDeleteEntryUseCase>;
export declare namespace DeleteEntryUseCase {
    type Interface = IDeleteEntryUseCase;
    type Options = CmsDeleteEntryOptions;
    type Error = UseCaseError;
    type Return = Promise<Result<void, UseCaseError>>;
}
/**
 * Payload for before delete event
 */
export interface EntryBeforeDeleteEventPayload {
    entry: CmsEntry;
    model: CmsModel;
    permanent: boolean;
}
/**
 * Payload for after delete event
 */
export interface EntryAfterDeleteEventPayload {
    entry: CmsEntry;
    model: CmsModel;
    permanent: boolean;
}
/**
 * Payload for delete error event
 */
export interface EntryDeleteErrorEventPayload {
    entry: CmsEntry;
    model: CmsModel;
    permanent: boolean;
    error: Error;
}
/**
 * DeleteEntryRepository - Handles storage operations for permanently deleting entries.
 */
export interface IDeleteEntryRepository {
    execute(model: CmsModel, entry: CmsEntry): Promise<Result<void, RepositoryError>>;
}
export interface IDeleteEntryRepositoryErrors {
    storage: EntryPersistenceError;
}
type RepositoryError = IDeleteEntryRepositoryErrors[keyof IDeleteEntryRepositoryErrors];
export declare const DeleteEntryRepository: import("@webiny/di").Abstraction<IDeleteEntryRepository>;
export declare namespace DeleteEntryRepository {
    type Interface = IDeleteEntryRepository;
    type Error = RepositoryError;
}
/**
 * MoveEntryToBin Use Case - Soft deletes an entry by marking it as deleted.
 * This moves the entry to the bin (trash) instead of permanently deleting it.
 */
export interface IMoveEntryToBinUseCase {
    execute(model: CmsModel, id: string): Promise<Result<void, UseCaseError>>;
}
/** Move a content entry to the recycle bin. */
export declare const MoveEntryToBinUseCase: import("@webiny/di").Abstraction<IMoveEntryToBinUseCase>;
export declare namespace MoveEntryToBinUseCase {
    type Interface = IMoveEntryToBinUseCase;
    type Error = UseCaseError;
}
/**
 * MoveEntryToBinRepository - Handles storage operations for soft deleting entries.
 */
export interface IMoveEntryToBinRepository {
    execute(params: {
        model: CmsModel;
        entry: CmsEntry;
    }): Promise<Result<void, RepositoryError>>;
}
export declare const MoveEntryToBinRepository: import("@webiny/di").Abstraction<IMoveEntryToBinRepository>;
export declare namespace MoveEntryToBinRepository {
    type Interface = IMoveEntryToBinRepository;
    type Error = RepositoryError;
}
export {};