@strapi/upload 0.0.0 → 5.0.0-beta.6

package/dist/server/src/index.d.ts

@@ -0,0 +1,475 @@
+/// <reference types="koa" />
+/// <reference types="node" />
+/// <reference types="styled-components" />
+/// <reference types="node" />
+import { register } from './register';
+import { bootstrap } from './bootstrap';
+declare const _default: () => {
+    register: typeof register;
+    bootstrap: typeof bootstrap;
+    config: {
+        default: {
+            enabled: boolean;
+            provider: string;
+            sizeLimit: number;
+            actionOptions: {};
+        };
+        validator(): void;
+    };
+    routes: {
+        admin: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: (string | {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    })[];
+                };
+            }[];
+        };
+        'content-api': {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+            }[];
+        };
+        viewConfiguration: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: (string | {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    })[];
+                };
+            }[];
+        };
+    };
+    controllers: {
+        'admin-file': {
+            find(ctx: import("koa").Context): Promise<import("koa").Context | {
+                results: any;
+                pagination: {
+                    page: number;
+                    pageSize: number;
+                    pageCount: number;
+                    total: number;
+                };
+            }>;
+            findOne(ctx: import("koa").Context): Promise<void>;
+            destroy(ctx: import("koa").Context): Promise<void>;
+        };
+        'admin-folder': {
+            findOne(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+            find(ctx: import("koa").Context): Promise<void>;
+            create(ctx: import("koa").Context): Promise<void>;
+            update(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+            getStructure(ctx: import("koa").Context): Promise<void>;
+        };
+        'admin-folder-file': {
+            deleteMany(ctx: import("koa").Context): Promise<void>;
+            moveMany(ctx: import("koa").Context): Promise<void>;
+        };
+        'admin-settings': {
+            updateSettings(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+            getSettings(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+        };
+        'admin-upload': {
+            updateFileInfo(ctx: import("koa").Context): Promise<void>;
+            replaceFile(ctx: import("koa").Context): Promise<void>;
+            uploadFiles(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+            upload(ctx: import("koa").Context): Promise<void>;
+        };
+        'content-api': ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            find(ctx: import("koa").Context): Promise<void>;
+            findOne(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+            destroy(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+            updateFileInfo(ctx: import("koa").Context): Promise<void>;
+            replaceFile(ctx: import("koa").Context): Promise<void>;
+            uploadFiles(ctx: import("koa").Context): Promise<void>;
+            upload(ctx: import("koa").Context): Promise<void>;
+        };
+        'view-configuration': {
+            updateViewConfiguration(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+            findViewConfiguration(ctx: import("koa").Context): Promise<void>;
+        };
+    };
+    contentTypes: {
+        file: {
+            schema: {
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {};
+                pluginOptions: {
+                    'content-manager': {
+                        visible: boolean;
+                    };
+                    'content-type-builder': {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    name: {
+                        type: "string";
+                        configurable: false;
+                        required: true;
+                    };
+                    alternativeText: {
+                        type: "string";
+                        configurable: false;
+                    };
+                    caption: {
+                        type: "string";
+                        configurable: false;
+                    };
+                    width: {
+                        type: "integer";
+                        configurable: false;
+                    };
+                    height: {
+                        type: "integer";
+                        configurable: false;
+                    };
+                    formats: {
+                        type: "json";
+                        configurable: false;
+                    };
+                    hash: {
+                        type: "string";
+                        configurable: false;
+                        required: true;
+                    };
+                    ext: {
+                        type: "string";
+                        configurable: false;
+                    };
+                    mime: {
+                        type: "string";
+                        configurable: false;
+                        required: true;
+                    };
+                    size: {
+                        type: "decimal";
+                        configurable: false;
+                        required: true;
+                    };
+                    url: {
+                        type: "string";
+                        configurable: false;
+                        required: true;
+                    };
+                    previewUrl: {
+                        type: "string";
+                        configurable: false;
+                    };
+                    provider: {
+                        type: "string";
+                        configurable: false;
+                        required: true;
+                    };
+                    provider_metadata: {
+                        type: "json";
+                        configurable: false;
+                    };
+                    related: {
+                        type: "relation";
+                        relation: "morphToMany";
+                        configurable: false;
+                    };
+                    folder: {
+                        type: "relation";
+                        relation: "manyToOne";
+                        target: "plugin::upload.folder";
+                        inversedBy: string;
+                        private: true;
+                    };
+                    folderPath: {
+                        type: "string";
+                        minLength: number;
+                        required: true;
+                        private: true;
+                        searchable: false;
+                    };
+                };
+                indexes: {
+                    name: string;
+                    columns: string[];
+                    type: null;
+                }[];
+            };
+        };
+        folder: {
+            schema: {
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                };
+                options: {};
+                pluginOptions: {
+                    'content-manager': {
+                        visible: boolean;
+                    };
+                    'content-type-builder': {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    name: {
+                        type: "string";
+                        minLength: number;
+                        required: true;
+                    };
+                    pathId: {
+                        type: "integer";
+                        unique: true;
+                        required: true;
+                    };
+                    parent: {
+                        type: "relation";
+                        relation: "manyToOne";
+                        target: "plugin::upload.folder";
+                        inversedBy: string;
+                    };
+                    children: {
+                        type: "relation";
+                        relation: "oneToMany";
+                        target: "plugin::upload.folder";
+                        mappedBy: string;
+                    };
+                    files: {
+                        type: "relation";
+                        relation: "oneToMany";
+                        target: "plugin::upload.file";
+                        mappedBy: string;
+                    };
+                    path: {
+                        type: "string";
+                        minLength: number;
+                        required: true;
+                    };
+                };
+                indexes: {
+                    name: string;
+                    columns: string[];
+                    type: string;
+                }[];
+            };
+        };
+    };
+    services: {
+        provider: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            checkFileSize(file: import("./types").UploadableFile): Promise<void>;
+            upload(file: import("./types").UploadableFile): Promise<void>;
+        };
+        upload: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            formatFileInfo: ({ filename, type, size }: {
+                filename: string;
+                type: string;
+                size: number;
+            }, fileInfo?: Partial<import("./types").FileInfo>, metas?: {
+                refId?: (string | number) | undefined;
+                ref?: string | undefined;
+                field?: string | undefined;
+                path?: string | undefined;
+                tmpWorkingDirectory?: string | undefined;
+            }) => Promise<Omit<import("./types").UploadableFile, "getStream">>;
+            upload: ({ data, files, }: {
+                data: Record<string, unknown>;
+                files: import("./types").InputFile | import("./types").InputFile[];
+            }, opts?: {
+                user?: {
+                    id: string | number;
+                } | undefined;
+            } | undefined) => Promise<any[]>;
+            updateFileInfo: (id: string | number, { name, alternativeText, caption, folder }: import("./types").FileInfo, opts?: {
+                user?: {
+                    id: string | number;
+                } | undefined;
+            } | undefined) => Promise<any>;
+            replace: (id: string | number, { data, file }: {
+                data: {
+                    fileInfo: import("./types").FileInfo;
+                };
+                file: import("./types").InputFile;
+            }, opts?: {
+                user?: {
+                    id: string | number;
+                } | undefined;
+            } | undefined) => Promise<any>;
+            findOne: (id: string | number, populate?: {}) => Promise<any>;
+            findMany: (query?: any) => Promise<import("./types").File[]>;
+            findPage: (query?: any) => Promise<{
+                results: any[];
+                pagination: {
+                    page: number;
+                    pageSize: number;
+                    pageCount: number;
+                    total: number;
+                };
+            }>;
+            remove: (file: import("./types").File) => Promise<any>;
+            getSettings: () => Promise<import("yup/lib/object").AssertsShape<{
+                sizeOptimization: import("yup/lib/boolean").RequiredBooleanSchema<boolean | undefined, Record<string, any>>;
+                responsiveDimensions: import("yup/lib/boolean").RequiredBooleanSchema<boolean | undefined, Record<string, any>>;
+                autoOrientation: import("yup").BooleanSchema<boolean | undefined, Record<string, any>, boolean | undefined>;
+            }> | null>;
+            setSettings: (value: import("yup/lib/object").AssertsShape<{
+                sizeOptimization: import("yup/lib/boolean").RequiredBooleanSchema<boolean | undefined, Record<string, any>>;
+                responsiveDimensions: import("yup/lib/boolean").RequiredBooleanSchema<boolean | undefined, Record<string, any>>;
+                autoOrientation: import("yup").BooleanSchema<boolean | undefined, Record<string, any>, boolean | undefined>;
+            }>) => Promise<void>;
+            getConfiguration: () => Promise<import("yup/lib/object").AssertsShape<{
+                pageSize: import("yup/lib/number").RequiredNumberSchema<number | undefined, Record<string, any>>;
+                sort: import("yup/lib/mixed").MixedSchema<any, Record<string, any>, any>;
+            }> | null>;
+            setConfiguration: (value: import("yup/lib/object").AssertsShape<{
+                pageSize: import("yup/lib/number").RequiredNumberSchema<number | undefined, Record<string, any>>;
+                sort: import("yup/lib/mixed").MixedSchema<any, Record<string, any>, any>;
+            }>) => Promise<void>;
+            _uploadImage: (fileData: import("./types").UploadableFile) => Promise<void>;
+        };
+        folder: {
+            create: (folderData: Pick<import("./types").Folder, "name" | "parent">, opts?: {
+                user: {
+                    id: string | number;
+                };
+            } | undefined) => Promise<any>;
+            exists: (params?: {}) => Promise<boolean>;
+            deleteByIds: (ids?: never[]) => Promise<{
+                folders: any[];
+                totalFolderNumber: number;
+                totalFileNumber: number;
+            }>;
+            update: (id: number, { name, parent, }: {
+                name: string;
+                parent: number | null;
+            }, { user }: {
+                user: {
+                    id: string | number;
+                };
+            }) => Promise<any>;
+            setPathIdAndPath: (folder: Pick<import("./types").Folder, "parent">) => Promise<Pick<import("./types").Folder, "parent"> & {
+                pathId: number;
+                path: string;
+            }>;
+            getStructure: () => Promise<number[] & (Partial<import("./types").Folder> & {
+                children: (Partial<import("./types").Folder> & any)[];
+            })[]>;
+        };
+        file: {
+            getFolderPath: (folderId?: number | null | undefined) => Promise<any>;
+            deleteByIds: (ids?: number[]) => Promise<any[]>;
+            signFileUrls: (file: import("./types").File) => Promise<import("./types").File>;
+        };
+        weeklyMetrics: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            computeMetrics(): Promise<{
+                assetNumber: number;
+                folderNumber: number;
+                averageDepth: number;
+                maxDepth: number;
+                averageDeviationDepth: number;
+            }>;
+            sendMetrics(): Promise<void>;
+            ensureWeeklyStoredCronSchedule(): Promise<string>;
+            registerCron(): Promise<void>;
+        };
+        metrics: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            sendUploadPluginMetrics(): Promise<void>;
+        };
+        'image-manipulation': {
+            isFaultyImage: (file: import("./types").UploadableFile) => Promise<unknown>;
+            isOptimizableImage: (file: import("./types").UploadableFile) => Promise<boolean | undefined>;
+            isResizableImage: (file: import("./types").UploadableFile) => Promise<boolean | undefined>;
+            isImage: (file: import("./types").UploadableFile) => Promise<boolean | undefined>;
+            getDimensions: (file: import("./types").UploadableFile) => Promise<{
+                width: number | null;
+                height: number | null;
+            }>;
+            generateResponsiveFormats: (file: import("./types").UploadableFile) => Promise<({
+                key: string;
+                file: import("./types").UploadableFile;
+            } | undefined)[]>;
+            generateThumbnail: (file: import("./types").UploadableFile) => Promise<import("./types").UploadableFile | null>;
+            optimize: (file: import("./types").UploadableFile) => Promise<{
+                getStream: () => NodeJS.ReadableStream;
+                stream?: NodeJS.ReadableStream | undefined;
+                buffer?: Buffer | undefined;
+                tmpWorkingDirectory?: string | undefined;
+                name: string;
+                alternativeText?: string | null | undefined;
+                caption?: string | null | undefined;
+                width?: number | undefined;
+                height?: number | undefined;
+                formats?: Record<string, unknown> | undefined;
+                hash: string;
+                ext?: string | undefined;
+                mime?: string | undefined;
+                size?: number | undefined;
+                sizeInBytes?: number | undefined;
+                url?: string | undefined;
+                previewUrl?: string | undefined;
+                path?: string | null | undefined;
+                provider?: string | undefined;
+                provider_metadata?: Record<string, unknown> | undefined;
+                isUrlSigned?: boolean | undefined;
+                folder?: number | undefined;
+                folderPath?: string | undefined;
+                related?: {
+                    id: string | number;
+                    __type: string;
+                    __pivot: {
+                        field: string;
+                    };
+                }[] | undefined;
+                createdAt?: string | undefined;
+                updatedAt?: string | undefined;
+                createdBy?: number | undefined;
+                updatedBy?: number | undefined;
+            } & {
+                width: number | undefined;
+                height: number | undefined;
+                size: number;
+                sizeInBytes: number | undefined;
+            }>;
+        };
+        'api-upload-folder': {
+            getAPIUploadFolder: () => Promise<any>;
+        };
+        extensions: {
+            contentManager: typeof import("./services/extensions/content-manager");
+            core: typeof import("./services/extensions/core");
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../server/src/index.ts"],"names":[],"mappings":";;;;AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOxC,wBAQG"}

package/dist/server/src/middlewares/upload.d.ts

@@ -0,0 +1,9 @@
+import type { Core } from '@strapi/types';
+/**
+ * Programmatic upload middleware. We do not want to expose it in the plugin
+ */
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default _default;
+//# sourceMappingURL=upload.d.ts.map

package/dist/server/src/middlewares/upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../../../server/src/middlewares/upload.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C;;GAEG;qCACyB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;AAAnD,wBAsBE"}

package/dist/server/src/register.d.ts

@@ -0,0 +1,8 @@
+import type { Core } from '@strapi/types';
+/**
+ * Register upload plugin
+ */
+export declare function register({ strapi }: {
+    strapi: Core.Strapi;
+}): Promise<void>;
+//# sourceMappingURL=register.d.ts.map

package/dist/server/src/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../server/src/register.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAS1C;;GAEG;AACH,wBAAsB,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAA;CAAE,iBAmBjE"}

package/dist/server/src/routes/admin.d.ts

@@ -0,0 +1,17 @@
+export declare const routes: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: (string | {
+                name: string;
+                config: {
+                    actions: string[];
+                };
+            })[];
+        };
+    }[];
+};
+//# sourceMappingURL=admin.d.ts.map

package/dist/server/src/routes/admin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin.d.ts","sourceRoot":"","sources":["../../../../server/src/routes/admin.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;CA4MlB,CAAC"}

package/dist/server/src/routes/content-api.d.ts

@@ -0,0 +1,9 @@
+export declare const routes: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+    }[];
+};
+//# sourceMappingURL=content-api.d.ts.map

package/dist/server/src/routes/content-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-api.d.ts","sourceRoot":"","sources":["../../../../server/src/routes/content-api.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM;;;;;;;CAwBlB,CAAC"}

package/dist/server/src/routes/index.d.ts

@@ -0,0 +1,43 @@
+export declare const routes: {
+    admin: {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: (string | {
+                    name: string;
+                    config: {
+                        actions: string[];
+                    };
+                })[];
+            };
+        }[];
+    };
+    'content-api': {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+        }[];
+    };
+    viewConfiguration: {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: (string | {
+                    name: string;
+                    config: {
+                        actions: string[];
+                    };
+                })[];
+            };
+        }[];
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/routes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/routes/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIlB,CAAC"}

package/dist/server/src/routes/view-configuration.d.ts

@@ -0,0 +1,17 @@
+export declare const routes: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: (string | {
+                name: string;
+                config: {
+                    actions: string[];
+                };
+            })[];
+        };
+    }[];
+};
+//# sourceMappingURL=view-configuration.d.ts.map

package/dist/server/src/routes/view-configuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-configuration.d.ts","sourceRoot":"","sources":["../../../../server/src/routes/view-configuration.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;CA4BlB,CAAC"}

package/dist/server/src/services/api-upload-folder.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    getAPIUploadFolder: () => Promise<any>;
+};
+export default _default;
+//# sourceMappingURL=api-upload-folder.d.ts.map

package/dist/server/src/services/api-upload-folder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-upload-folder.d.ts","sourceRoot":"","sources":["../../../../server/src/services/api-upload-folder.ts"],"names":[],"mappings":";;;AAsCA,wBAEE"}

package/dist/server/src/services/extensions/content-manager/entity-manager.d.ts

@@ -0,0 +1,15 @@
+import type { UID } from '@strapi/types';
+/**
+ *
+ * Iterate through an entity manager result
+ * Check which modelAttributes are media and pre sign the image URLs
+ * if they are from the current upload provider
+ *
+ * @param {Object} entity
+ * @param {Object} modelAttributes
+ * @returns
+ */
+declare const signEntityMedia: (entity: any, uid: UID.Schema) => Promise<import("@strapi/utils/dist/types").Data>;
+declare const addSignedFileUrlsToAdmin: () => Promise<void>;
+export { addSignedFileUrlsToAdmin, signEntityMedia };
+//# sourceMappingURL=entity-manager.d.ts.map

package/dist/server/src/services/extensions/content-manager/entity-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-manager.d.ts","sourceRoot":"","sources":["../../../../../../server/src/services/extensions/content-manager/entity-manager.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAU,GAAG,EAAE,MAAM,eAAe,CAAC;AAmDjD;;;;;;;;;GASG;AACH,QAAA,MAAM,eAAe,WAAkB,GAAG,OAAO,IAAI,MAAM,qDAQ1D,CAAC;AAEF,QAAA,MAAM,wBAAwB,qBAqB7B,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,eAAe,EAAE,CAAC"}

package/dist/server/src/services/extensions/content-manager/index.d.ts

@@ -0,0 +1,4 @@
+export declare const entityManager: {
+    addSignedFileUrlsToAdmin: () => Promise<void>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/services/extensions/content-manager/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../server/src/services/extensions/content-manager/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;CAA+B,CAAC"}

package/dist/server/src/services/extensions/core/entity-service.d.ts

@@ -0,0 +1,4 @@
+import { signEntityMedia } from '../utils';
+declare const addSignedFileUrlsToEntityService: () => Promise<void>;
+export { addSignedFileUrlsToEntityService, signEntityMedia };
+//# sourceMappingURL=entity-service.d.ts.map

package/dist/server/src/services/extensions/core/entity-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-service.d.ts","sourceRoot":"","sources":["../../../../../../server/src/services/extensions/core/entity-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE3C,QAAA,MAAM,gCAAgC,qBAwBrC,CAAC;AAEF,OAAO,EAAE,gCAAgC,EAAE,eAAe,EAAE,CAAC"}

package/dist/server/src/services/extensions/core/index.d.ts

@@ -0,0 +1,4 @@
+export declare const entityService: {
+    addSignedFileUrlsToEntityService: () => Promise<void>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/services/extensions/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../server/src/services/extensions/core/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;CAAuC,CAAC"}