bknd/dist/types/media/AppMedia.d.ts

Lightweight Firebase/Supabase alternative built to run anywhere — incl. Next.js, React Router, Astro, Cloudflare, Bun, Node, AWS Lambda & more.

import type { AppEntity, FileUploadedEventData } from "..";
import type { Entity, EntityManager } from "../data/entities";
import { Storage } from "../media/storage/Storage";
import { Module } from "../modules/Module";
import { type FieldSchema } from "../data/prototype";
import { type TAppMediaConfig } from "./media-schema";
export type MediaFields = typeof AppMedia.mediaFields;
export type MediaFieldSchema = FieldSchema<typeof AppMedia.mediaFields>;
declare module ".." {
    interface Media extends AppEntity, MediaFieldSchema {
    }
    interface DB {
        media: Media;
    }
}
export declare class AppMedia extends Module<Required<TAppMediaConfig>> {
    private _storage?;
    options: {
        body_max_size: number | null;
    };
    build(): Promise<void>;
    getSchema(): import("jsonv-ts").ObjectSchema<{
        readonly enabled: import("jsonv-ts").Schema<{
            readonly default: false;
        }, boolean, boolean> & {
            readonly default: false;
        };
        readonly basepath: import("jsonv-ts").StringSchema<{
            readonly default: "/api/media";
        }> & {
            readonly default: "/api/media";
        };
        readonly entity_name: import("jsonv-ts").StringSchema<{
            readonly default: "media";
        }> & {
            readonly default: "media";
        };
        readonly storage: import("jsonv-ts").ObjectSchema<{
            readonly body_max_size: {} & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
        }, import("jsonv-ts").Merge<{
            readonly default: {};
        } & {
            additionalProperties: false;
        }>>;
        readonly adapter: {
            default?: any;
            enum?: (readonly any[] | any[]) | undefined;
            const?: any;
            anyOf: import("jsonv-ts").ObjectSchema<{
                readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, string, string> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                    const: string;
                }>;
                readonly config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, unknown, unknown>;
            }, import("jsonv-ts").Merge<{
                readonly title: string;
                readonly description: string | undefined;
            } & {
                additionalProperties: false;
            }>>[];
        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
            config?: unknown;
            type: string;
        } | undefined, never>;
    }, import("jsonv-ts").Merge<{
        readonly default: {};
    } & {
        additionalProperties: false;
    }>>;
    get basepath(): string;
    get storage(): Storage;
    uploadedEventDataToMediaPayload(info: FileUploadedEventData): MediaFieldSchema;
    static mediaFields: {
        path: import("../data/fields").TextField<true>;
        folder: import("../data/fields").BooleanField<false> & {
            required: () => import("../data/fields").BooleanField<true>;
        };
        mime_type: import("../data/fields").TextField<false> & {
            required: () => import("../data/fields").TextField<true>;
        };
        size: import("../data/fields").NumberField<false> & {
            required: () => import("../data/fields").NumberField<true>;
        };
        scope: import("../data/fields").TextField<false> & {
            required: () => import("../data/fields").TextField<true>;
        };
        etag: import("../data/fields").TextField<false> & {
            required: () => import("../data/fields").TextField<true>;
        };
        modified_at: import("../data/fields").DateField<false> & {
            required: () => import("../data/fields").DateField<true>;
        };
        reference: import("../data/fields").TextField<false> & {
            required: () => import("../data/fields").TextField<true>;
        };
        entity_id: import("../data/fields").TextField<false> & {
            required: () => import("../data/fields").TextField<true>;
        };
        metadata: import("../data/fields").JsonField<false, object> & {
            required: () => import("../data/fields").JsonField<true, object>;
        };
    };
    getMediaEntity(forceCreate?: boolean): Entity<"media", typeof AppMedia.mediaFields>;
    get em(): EntityManager;
    private setupListeners;
    getOverwritePaths(): RegExp[];
    toJSON(secrets?: boolean): {
        adapter: any;
        enabled: boolean;
        basepath: string;
        entity_name: string;
        storage: {
            body_max_size?: number | undefined;
        };
    };
}