import { DeleteDone, ImageHandler, SoundHandler } from '@pie-players/pie-players-shared/types';
export type BackendScope = "delivery" | "authoring";
export type BackendProvider = "custom" | "pie-api";
export type BackendMethod = "POST" | "PUT" | "PATCH" | "DELETE";
export type BackendEndpoint = string | {
    method?: BackendMethod;
    path: string;
};
export type BackendAuthConfig = {
    token?: string;
    getToken?: () => string | Promise<string | null | undefined>;
};
export type BackendRequestConfig = {
    headers?: Record<string, string>;
    timeoutMs?: number;
};
export type BackendRequestOptions = {
    overrides?: Record<string, string>;
};
export type BackendAutosaveConfig = boolean | {
    enabled?: boolean;
    debounceMs?: number;
};
export type BackendDeliveryIdentity = {
    itemId?: string;
    sessionId?: string;
    assignmentId?: string;
};
export type BackendDeliveryEndpoints = {
    load?: BackendEndpoint;
    saveSession?: BackendEndpoint;
    model?: BackendEndpoint;
    score?: BackendEndpoint;
};
export type BackendDeliveryLoadContext = BackendDeliveryIdentity & {
    env: unknown;
    requestOptions?: BackendRequestOptions;
};
export type BackendDeliveryModelIdentity = {
    id: string;
    element: string;
};
export type BackendDeliverySessionContext = BackendDeliveryIdentity & {
    session: {
        id: string;
        data: unknown[];
    };
    env: unknown;
    models?: BackendDeliveryModelIdentity[];
    passageModels?: BackendDeliveryModelIdentity[];
    requestOptions?: BackendRequestOptions;
};
export type BackendScoreOptions = {
    disablePartialScoring?: boolean;
    [key: string]: unknown;
};
export type BackendAuthoringIdentity = {
    contentId?: string;
    collectionId?: string;
};
export type BackendAuthoringSaveOptions = {
    preReleaseType?: string | null;
    [key: string]: unknown;
};
export type BackendSaveContentOptions = BackendAuthoringSaveOptions;
export type BackendAuthoringReleaseOptions = {
    releaseType?: string | null;
    [key: string]: unknown;
};
export type BackendAuthoringImageHandler = ImageHandler;
export type BackendAuthoringSoundHandler = SoundHandler;
export type BackendAuthoringMediaConfig = {
    onInsertImage?: (handler: BackendAuthoringImageHandler) => void;
    onDeleteImage?: (src: string, done: DeleteDone) => void;
    onInsertSound?: (handler: BackendAuthoringSoundHandler) => void;
    onDeleteSound?: (src: string, done: DeleteDone) => void;
};
export type BackendAuthoringEndpoints = {
    load?: BackendEndpoint;
    saveContent?: BackendEndpoint;
    releaseContent?: BackendEndpoint;
};
export type BackendAuthoringLoadResult = {
    contentId?: string;
    config: unknown;
    metadata?: Record<string, unknown>;
};
export type BackendAuthoringSaveContext = BackendAuthoringIdentity & {
    config: unknown;
    env: unknown;
    options?: BackendAuthoringSaveOptions;
};
export type BackendAuthoringReleaseContext = BackendAuthoringIdentity & {
    env: unknown;
    options?: BackendAuthoringReleaseOptions;
};
export type BackendAuthoringClient = {
    load?: (context: BackendAuthoringIdentity & {
        env: unknown;
    }) => Promise<BackendAuthoringLoadResult>;
    saveContent?: (context: BackendAuthoringSaveContext) => Promise<{
        contentId: string;
    }>;
    releaseContent?: (context: BackendAuthoringReleaseContext) => Promise<{
        contentId: string;
    }>;
};
export type BackendDeliveryScoreContext = BackendDeliverySessionContext & {
    options?: BackendScoreOptions;
};
export type BackendDeliveryLoadResult = {
    config?: unknown;
    item?: unknown;
    session?: unknown;
    metadata?: Record<string, unknown>;
};
export type BackendDeliveryModelResult = Array<Record<string, unknown>> | {
    models?: Array<Record<string, unknown>>;
    passageModels?: Array<Record<string, unknown>>;
    metadata?: Record<string, unknown>;
};
export type BackendDeliveryClient = {
    load?: (context: BackendDeliveryLoadContext) => Promise<BackendDeliveryLoadResult>;
    saveSession?: (context: BackendDeliverySessionContext) => Promise<unknown>;
    model?: (context: BackendDeliverySessionContext) => Promise<BackendDeliveryModelResult>;
    score?: (context: BackendDeliveryScoreContext) => Promise<unknown>;
};
export type BackendDeliveryConfig = BackendDeliveryIdentity & {
    enabled?: boolean;
    provider?: BackendProvider;
    baseUrl?: string;
    endpoints?: BackendDeliveryEndpoints;
    options?: BackendRequestOptions;
    request?: BackendRequestConfig;
    auth?: BackendAuthConfig;
    autosave?: BackendAutosaveConfig;
    client?: BackendDeliveryClient;
};
export type BackendAuthoringConfig = BackendAuthoringIdentity & {
    enabled?: boolean;
    provider?: BackendProvider;
    baseUrl?: string;
    endpoints?: BackendAuthoringEndpoints;
    request?: BackendRequestConfig;
    auth?: BackendAuthConfig;
    media?: BackendAuthoringMediaConfig;
    client?: BackendAuthoringClient;
};
export type BackendConfig = {
    auth?: BackendAuthConfig;
    delivery?: BackendDeliveryConfig;
    authoring?: BackendAuthoringConfig;
};
export type BackendLoadResult = {
    config: unknown;
    session: unknown;
    metadata?: Record<string, unknown>;
};
export type BackendEventDetail = {
    scope: BackendScope;
    operation: string;
    message?: string;
    error?: unknown;
    [key: string]: unknown;
};