@strapi/content-manager 0.0.0-experimental.a65a85fdea97faae8679d3ffc5f9d79af61abd26 → 0.0.0

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

@@ -1,374 +0,0 @@
-declare const _default: () => {
-    register: ({ strapi }: {
-        strapi: import("@strapi/types/dist/core").Strapi;
-    }) => void | Promise<void>;
-    bootstrap: () => Promise<void>;
-    destroy: ({ strapi }: {
-        strapi: import("@strapi/types/dist/core").Strapi;
-    }) => void | Promise<void>;
-    controllers: {
-        'collection-types': {
-            find(ctx: any): Promise<any>;
-            findOne(ctx: any): Promise<any>;
-            create(ctx: any): Promise<void>;
-            update(ctx: any): Promise<void>;
-            clone(ctx: any): Promise<any>;
-            autoClone(ctx: any): Promise<any>;
-            delete(ctx: any): Promise<any>;
-            publish(ctx: any): Promise<any>;
-            bulkPublish(ctx: any): Promise<any>;
-            bulkUnpublish(ctx: any): Promise<any>;
-            unpublish(ctx: any): Promise<any>;
-            discard(ctx: any): Promise<any>;
-            bulkDelete(ctx: any): Promise<any>;
-            countDraftRelations(ctx: any): Promise<any>;
-            countManyEntriesDraftRelations(ctx: any): Promise<any>;
-        };
-        components: {
-            findComponents(ctx: any): void;
-            findComponentConfiguration(ctx: any): Promise<any>;
-            updateComponentConfiguration(ctx: any): Promise<any>;
-        };
-        'content-types': {
-            findContentTypes(ctx: any): Promise<any>;
-            findContentTypesSettings(ctx: any): Promise<void>;
-            findContentTypeConfiguration(ctx: any): Promise<any>;
-            updateContentTypeConfiguration(ctx: any): Promise<any>;
-        };
-        init: {
-            getInitData(ctx: any): void;
-        };
-        relations: {
-            extractAndValidateRequestInfo(ctx: any, id?: import("@strapi/types/dist/data").ID | undefined): Promise<any>;
-            findAvailable(ctx: any): Promise<void>;
-            findExisting(ctx: any): Promise<void>;
-        };
-        'single-types': {
-            find(ctx: any): Promise<any>;
-            createOrUpdate(ctx: any): Promise<void>;
-            delete(ctx: any): Promise<any>;
-            publish(ctx: any): Promise<any>;
-            unpublish(ctx: any): Promise<any>;
-            discard(ctx: any): Promise<any>;
-            countDraftRelations(ctx: any): Promise<any>;
-        };
-        uid: {
-            generateUID(ctx: any): Promise<void>;
-            checkUIDAvailability(ctx: any): Promise<void>;
-        };
-    };
-    routes: {
-        admin: {
-            type: string;
-            routes: ({
-                method: string;
-                path: string;
-                handler: string;
-                config: {
-                    policies: string[];
-                    middlewares?: undefined;
-                };
-            } | {
-                method: string;
-                path: string;
-                handler: string;
-                config: {
-                    middlewares: ((ctx: import("koa").Context, next: import("koa").Next) => Promise<any>)[];
-                    policies: (string | {
-                        name: string;
-                        config: {
-                            actions: string[];
-                        };
-                    })[];
-                };
-            } | {
-                method: string;
-                path: string;
-                handler: string;
-                config: {
-                    middlewares: ((ctx: import("koa").Context, next: import("koa").Next) => Promise<any>)[];
-                    policies: (string | {
-                        name: string;
-                        config: {
-                            actions: string[];
-                            hasAtLeastOne: boolean;
-                        };
-                    })[];
-                };
-            })[];
-        };
-    };
-    policies: {
-        hasPermissions: {
-            name: string;
-            validator: (config: unknown) => void;
-            handler: (...args: any[]) => any;
-        };
-    };
-    services: {
-        components: ({ strapi }: {
-            strapi: import("@strapi/types/dist/core").Strapi;
-        }) => {
-            findAllComponents(): unknown[];
-            findComponent(uid: `${string}.${string}`): any;
-            findConfiguration(component: import("@strapi/types/dist/struct").ComponentSchema): Promise<{
-                uid: string;
-                settings: import("../../shared/contracts/content-types").Settings;
-                metadatas: import("../../shared/contracts/content-types").Metadatas;
-                layouts: import("../../shared/contracts/content-types").Layouts;
-                options?: object | undefined;
-                category: string;
-            }>;
-            updateConfiguration(component: import("@strapi/types/dist/struct").ComponentSchema, newConfiguration: import("./services/configuration").ConfigurationUpdate): Promise<{
-                uid: string;
-                settings: import("../../shared/contracts/content-types").Settings;
-                metadatas: import("../../shared/contracts/content-types").Metadatas;
-                layouts: import("../../shared/contracts/content-types").Layouts;
-                options?: object | undefined;
-                category: string;
-            }>;
-            findComponentsConfigurations(model: import("@strapi/types/dist/struct").ComponentSchema): Promise<Record<string, import("../../shared/contracts/content-types").Configuration & {
-                category: string;
-                isComponent: boolean;
-            }>>;
-            syncConfigurations(): Promise<void>;
-        };
-        'content-types': ({ strapi }: {
-            strapi: import("@strapi/types/dist/core").Strapi;
-        }) => {
-            findAllContentTypes(): unknown[];
-            findContentType(uid: import("@strapi/types/dist/uid").ContentType): any;
-            findDisplayedContentTypes(): unknown[];
-            findContentTypesByKind(kind: {
-                kind: import("@strapi/types/dist/struct").ContentTypeKind | undefined;
-            }): unknown[];
-            findConfiguration(contentType: import("@strapi/types/dist/struct").ContentTypeSchema): Promise<any>;
-            updateConfiguration(contentType: import("@strapi/types/dist/struct").ContentTypeSchema, newConfiguration: import("./services/configuration").ConfigurationUpdate): Promise<any>;
-            findComponentsConfigurations(contentType: import("@strapi/types/dist/struct").ContentTypeSchema): any;
-            syncConfigurations(): Promise<void>;
-        };
-        'data-mapper': () => {
-            toContentManagerModel(contentType: import("@strapi/types/dist/struct").ComponentSchema): {
-                apiID: string;
-                isDisplayed: boolean;
-                attributes: any;
-                modelType: "component";
-                uid: `${string}.${string}`;
-                category: string;
-                modelName: string;
-                globalId: string;
-                pluginOptions?: import("@strapi/types/dist/struct").SchemaPluginOptions | undefined;
-                options?: import("@strapi/types/dist/struct").SchemaOptions | undefined;
-                collectionName?: string | undefined;
-                info: import("@strapi/types/dist/struct").SchemaInfo;
-            };
-            toDto: import("lodash/fp").LodashPick2x1;
-        };
-        'document-metadata': ({ strapi }: {
-            strapi: import("@strapi/types/dist/core").Strapi;
-        }) => {
-            getAvailableLocales(uid: import("@strapi/types/dist/uid").ContentType, version: import("./services/document-metadata").DocumentVersion, allVersions: import("./services/document-metadata").DocumentVersion[]): (Partial<import("./services/document-metadata").DocumentVersion> | {
-                status: string;
-                id?: string | undefined;
-                documentId?: string | undefined;
-                locale?: string | undefined;
-                updatedAt?: string | Date | null | undefined;
-                publishedAt?: string | Date | null | undefined;
-            } | undefined)[];
-            getAvailableStatus(version: import("./services/document-metadata").DocumentVersion, allVersions: import("./services/document-metadata").DocumentVersion[]): Partial<import("./services/document-metadata").DocumentVersion> | undefined;
-            getManyAvailableStatus(uid: import("@strapi/types/dist/uid").ContentType, documents: import("./services/document-metadata").DocumentVersion[]): Promise<Pick<import("@strapi/types/dist/modules/documents").AnyDocument, "id" | ("createdAt" | "updatedAt" | "publishedAt") | ("createdBy" | "updatedBy" | "publishedBy")>[]>;
-            getStatus(version: import("./services/document-metadata").DocumentVersion, otherDocumentStatuses?: Pick<import("@strapi/types/dist/modules/documents").AnyDocument, "id" | ("createdAt" | "updatedAt" | "publishedAt") | ("createdBy" | "updatedBy" | "publishedBy")>[] | undefined): string;
-            getMetadata(uid: import("@strapi/types/dist/uid").ContentType, version: import("./services/document-metadata").DocumentVersion, { availableLocales, availableStatus }?: import("./services/document-metadata").GetMetadataOptions): Promise<{
-                availableLocales: (Partial<import("./services/document-metadata").DocumentVersion> | {
-                    status: string;
-                    id?: string | undefined;
-                    documentId?: string | undefined;
-                    locale?: string | undefined;
-                    updatedAt?: string | Date | null | undefined;
-                    publishedAt?: string | Date | null | undefined;
-                } | undefined)[];
-                availableStatus: Partial<import("./services/document-metadata").DocumentVersion>[];
-            }>;
-            formatDocumentWithMetadata(uid: import("@strapi/types/dist/uid").ContentType, document: import("./services/document-metadata").DocumentVersion, opts?: import("./services/document-metadata").GetMetadataOptions): Promise<{
-                data: {
-                    status: string | undefined;
-                    id: string;
-                    documentId: string;
-                    locale: string;
-                    updatedAt: string | Date | null;
-                    publishedAt: string | Date | null;
-                };
-                meta: {
-                    availableLocales: (Partial<import("./services/document-metadata").DocumentVersion> | {
-                        status: string;
-                        id?: string | undefined;
-                        documentId?: string | undefined;
-                        locale?: string | undefined;
-                        updatedAt?: string | Date | null | undefined;
-                        publishedAt?: string | Date | null | undefined;
-                    } | undefined)[];
-                    availableStatus: Partial<import("./services/document-metadata").DocumentVersion>[];
-                };
-            }>;
-        };
-        'document-manager': ({ strapi }: {
-            strapi: import("@strapi/types/dist/core").Strapi;
-        }) => {
-            findOne(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").FindOne<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
-            findLocales(id: string | undefined, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts: {
-                populate?: {
-                    populate?: import("@strapi/types/dist/modules/documents/params/populate").Any<any> | undefined;
-                } | undefined;
-                locale?: string | string[] | undefined;
-            }): Promise<any[]>;
-            findMany(opts: import("@strapi/types/dist/modules/documents/params/document-engine").FindMany<import("@strapi/types/dist/uid").ContentType> | undefined, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`): Promise<import("@strapi/types/dist/modules/documents").AnyDocument[]>;
-            findPage(opts: import("@strapi/types/dist/modules/documents/params/document-engine").FindMany<import("@strapi/types/dist/uid").ContentType> | undefined, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`): Promise<{
-                results: import("@strapi/types/dist/modules/documents").AnyDocument[];
-                pagination: {
-                    page: number;
-                    pageSize: number;
-                    pageCount: number;
-                    total: number;
-                };
-            }>;
-            create(uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: import("@strapi/types/dist/modules/documents/params/document-engine").Create<import("@strapi/types/dist/uid").ContentType>): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
-            update(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Update<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
-            clone(id: string, body: Partial<import("@strapi/types/dist/modules/documents/params/data").Input<`admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`>>, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | undefined>;
-            exists(uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, id?: string | undefined): Promise<boolean>;
-            delete(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Delete<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<{}>;
-            deleteMany(opts: import("@strapi/types/dist/modules/documents/params/document-engine").FindMany<import("@strapi/types/dist/uid").ContentType> | undefined, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`): Promise<{
-                count: number;
-            }>;
-            publish(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Publish<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | undefined>;
-            publishMany(entities: import("@strapi/types/dist/modules/documents").AnyDocument[], uid: import("@strapi/types/dist/uid").ContentType): Promise<import("@strapi/database/dist/types").CountResult | null>;
-            unpublishMany(documents: import("@strapi/types/dist/modules/documents").AnyDocument[], uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`): Promise<import("@strapi/database/dist/types").CountResult | null>;
-            unpublish(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").Unpublish<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | undefined>;
-            discardDraft(id: string, uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: Omit<import("@strapi/types/dist/modules/documents/params/document-engine").DiscardDraft<import("@strapi/types/dist/uid").ContentType>, "documentId">): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | undefined>;
-            countDraftRelations(id: string, uid: import("@strapi/types/dist/uid").ContentType, locale: string): Promise<number>;
-            countManyEntriesDraftRelations(ids: number[], uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, locale: string): Promise<number>;
-        };
-        'field-sizes': ({ strapi }: {
-            strapi: import("@strapi/types/dist/core").Strapi;
-        }) => {
-            getAllFieldSizes(): Record<string, {
-                default: 8 | 6 | 4 | 12;
-                isResizable: boolean;
-            } | undefined>;
-            hasFieldSize(type: string): boolean;
-            getFieldSize(type?: string | undefined): {
-                default: 8 | 6 | 4 | 12;
-                isResizable: boolean;
-            };
-            setFieldSize(type: string, size: {
-                default: 8 | 6 | 4 | 12;
-                isResizable: boolean;
-            } | undefined): void;
-            setCustomFieldInputSizes(): void;
-        };
-        metrics: ({ strapi }: {
-            strapi: import("@strapi/types/dist/core").Strapi;
-        }) => {
-            sendDidConfigureListView: (contentType: import("@strapi/types/dist/struct").ContentTypeSchema, configuration: import("../../shared/contracts/content-types").Configuration) => Promise<void>;
-        };
-        'permission-checker': ({ strapi }: {
-            strapi: import("@strapi/types/dist/core").Strapi;
-        }) => {
-            create: ({ userAbility, model }: {
-                userAbility: any;
-                model: string;
-            }) => {
-                can: (action: string, entity?: ({
-                    id: import("@strapi/types/dist/data").ID;
-                } & {
-                    [key: string]: any;
-                }) | undefined, field: string) => any;
-                cannot: (action: string, entity?: ({
-                    id: import("@strapi/types/dist/data").ID;
-                } & {
-                    [key: string]: any;
-                }) | undefined, field: string) => any;
-                sanitizeOutput: (data: {
-                    id: import("@strapi/types/dist/data").ID;
-                } & {
-                    [key: string]: any;
-                }, { action }?: {
-                    action?: string | undefined;
-                }) => any;
-                sanitizeQuery: (query: {
-                    page?: string | undefined;
-                    pageSize?: string | undefined;
-                    sort?: string | undefined;
-                }, { action }?: {
-                    action?: string | undefined;
-                }) => any;
-                sanitizeCreateInput: (data: any) => any;
-                sanitizeUpdateInput: (entity: {
-                    id: import("@strapi/types/dist/data").ID;
-                } & {
-                    [key: string]: any;
-                }) => (data: any) => any;
-                validateQuery: (query: {
-                    page?: string | undefined;
-                    pageSize?: string | undefined;
-                    sort?: string | undefined;
-                }, { action }?: {
-                    action?: string | undefined;
-                }) => any;
-                validateInput: (action: string, data: any, entity?: ({
-                    id: import("@strapi/types/dist/data").ID;
-                } & {
-                    [key: string]: any;
-                }) | undefined) => any;
-                sanitizedQuery: (query: {
-                    page?: string | undefined;
-                    pageSize?: string | undefined;
-                    sort?: string | undefined;
-                }, action?: {
-                    action?: string | undefined;
-                }) => Promise<any>;
-            };
-        };
-        permission: ({ strapi }: {
-            strapi: import("@strapi/types/dist/core").Strapi;
-        }) => {
-            canConfigureContentType({ userAbility, contentType, }: {
-                userAbility: any;
-                contentType: import("@strapi/types/dist/struct").ContentTypeSchema;
-            }): any;
-            registerPermissions(): Promise<void>;
-        };
-        'populate-builder': () => (uid: import("@strapi/types/dist/uid").Schema) => {
-            populateFromQuery(query: object): any;
-            countRelations({ toMany, toOne }?: {
-                toMany: boolean;
-                toOne: boolean;
-            }): any;
-            populateDeep(level?: number): any;
-            build(): Promise<{} | undefined>;
-        };
-        uid: ({ strapi }: {
-            strapi: import("@strapi/types/dist/core").Strapi;
-        }) => {
-            generateUIDField({ contentTypeUID, field, data, locale, }: {
-                contentTypeUID: import("@strapi/types/dist/uid").ContentType;
-                field: string;
-                data: Record<string, any>;
-                locale?: string | undefined;
-            }): Promise<string>;
-            findUniqueUID({ contentTypeUID, field, value, locale, }: {
-                contentTypeUID: import("@strapi/types/dist/uid").ContentType;
-                field: string;
-                value: string;
-                locale?: string | undefined;
-            }): Promise<string>;
-            checkUIDAvailability({ contentTypeUID, field, value, locale, }: {
-                contentTypeUID: import("@strapi/types/dist/uid").ContentType;
-                field: string;
-                value: string;
-                locale?: string | undefined;
-            }): Promise<boolean>;
-        };
-    };
-};
-export default _default;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../server/src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,wBAUE"}

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

@@ -1,3 +0,0 @@
-import routing from './routing';
-export { routing };
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/middlewares/index.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,WAAW,CAAC;AAEhC,OAAO,EAAE,OAAO,EAAE,CAAC"}

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

@@ -1,4 +0,0 @@
-import type { Context, Next } from 'koa';
-declare const _default: (ctx: Context, next: Next) => Promise<any>;
-export default _default;
-//# sourceMappingURL=routing.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../../../server/src/middlewares/routing.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,KAAK,CAAC;8BAOd,OAAO,QAAQ,IAAI;AAA9C,wBAwCE"}

package/dist/server/src/policies/hasPermissions.d.ts

@@ -1,7 +0,0 @@
-declare const _default: {
-    name: string;
-    validator: (config: unknown) => void;
-    handler: (...args: any[]) => any;
-};
-export default _default;
-//# sourceMappingURL=hasPermissions.d.ts.map

package/dist/server/src/policies/hasPermissions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hasPermissions.d.ts","sourceRoot":"","sources":["../../../../server/src/policies/hasPermissions.ts"],"names":[],"mappings":";;;;;AAMA,wBAgBG"}

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

@@ -1,9 +0,0 @@
-declare const _default: {
-    hasPermissions: {
-        name: string;
-        validator: (config: unknown) => void;
-        handler: (...args: any[]) => any;
-    };
-};
-export default _default;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/policies/index.ts"],"names":[],"mappings":";;;;;;;AAEA,wBAEE"}

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

@@ -1,4 +0,0 @@
-import type { Plugin } from '@strapi/types';
-declare const register: Plugin.LoadedPlugin['register'];
-export default register;
-//# sourceMappingURL=register.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../server/src/register.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAG5C,QAAA,MAAM,QAAQ,EAAE,MAAM,CAAC,YAAY,CAAC,UAAU,CAE7C,CAAC;AAEF,eAAe,QAAQ,CAAC"}

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

@@ -1,41 +0,0 @@
-declare const _default: {
-    type: string;
-    routes: ({
-        method: string;
-        path: string;
-        handler: string;
-        config: {
-            policies: string[];
-            middlewares?: undefined;
-        };
-    } | {
-        method: string;
-        path: string;
-        handler: string;
-        config: {
-            middlewares: ((ctx: import("koa").Context, next: import("koa").Next) => Promise<any>)[];
-            policies: (string | {
-                name: string;
-                config: {
-                    actions: string[];
-                };
-            })[];
-        };
-    } | {
-        method: string;
-        path: string;
-        handler: string;
-        config: {
-            middlewares: ((ctx: import("koa").Context, next: import("koa").Next) => Promise<any>)[];
-            policies: (string | {
-                name: string;
-                config: {
-                    actions: string[];
-                    hasAtLeastOne: boolean;
-                };
-            })[];
-        };
-    })[];
-};
-export default _default;
-//# sourceMappingURL=admin.d.ts.map

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

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

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

@@ -1,43 +0,0 @@
-declare const _default: {
-    admin: {
-        type: string;
-        routes: ({
-            method: string;
-            path: string;
-            handler: string;
-            config: {
-                policies: string[];
-                middlewares?: undefined;
-            };
-        } | {
-            method: string;
-            path: string;
-            handler: string;
-            config: {
-                middlewares: ((ctx: import("koa").Context, next: import("koa").Next) => Promise<any>)[];
-                policies: (string | {
-                    name: string;
-                    config: {
-                        actions: string[];
-                    };
-                })[];
-            };
-        } | {
-            method: string;
-            path: string;
-            handler: string;
-            config: {
-                middlewares: ((ctx: import("koa").Context, next: import("koa").Next) => Promise<any>)[];
-                policies: (string | {
-                    name: string;
-                    config: {
-                        actions: string[];
-                        hasAtLeastOne: boolean;
-                    };
-                })[];
-            };
-        })[];
-    };
-};
-export default _default;
-//# sourceMappingURL=index.d.ts.map

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

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

package/dist/server/src/services/components.d.ts

@@ -1,32 +0,0 @@
-import type { UID, Struct, Core } from '@strapi/types';
-import type { Configuration } from '../../../shared/contracts/content-types';
-import type { ConfigurationUpdate } from './configuration';
-declare const _default: ({ strapi }: {
-    strapi: Core.Strapi;
-}) => {
-    findAllComponents(): unknown[];
-    findComponent(uid: UID.Component): any;
-    findConfiguration(component: Struct.ComponentSchema): Promise<{
-        uid: string;
-        settings: import("../../../shared/contracts/content-types").Settings;
-        metadatas: import("../../../shared/contracts/content-types").Metadatas;
-        layouts: import("../../../shared/contracts/content-types").Layouts;
-        options?: object | undefined;
-        category: string;
-    }>;
-    updateConfiguration(component: Struct.ComponentSchema, newConfiguration: ConfigurationUpdate): Promise<{
-        uid: string;
-        settings: import("../../../shared/contracts/content-types").Settings;
-        metadatas: import("../../../shared/contracts/content-types").Metadatas;
-        layouts: import("../../../shared/contracts/content-types").Layouts;
-        options?: object | undefined;
-        category: string;
-    }>;
-    findComponentsConfigurations(model: Struct.ComponentSchema): Promise<Record<string, Configuration & {
-        category: string;
-        isComponent: boolean;
-    }>>;
-    syncConfigurations(): Promise<void>;
-};
-export default _default;
-//# sourceMappingURL=components.d.ts.map

package/dist/server/src/services/components.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../../../server/src/services/components.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;qCAmB/B;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;uBAO9B,IAAI,SAAS;iCAQG,OAAO,eAAe;;;;;;;;mCAW5C,OAAO,eAAe,oBACf,mBAAmB;;;;;;;;wCAOG,OAAO,eAAe;kBAGhC,MAAM;qBAAe,OAAO;;;;AArC9D,wBA4EG"}

package/dist/server/src/services/configuration.d.ts

@@ -1,20 +0,0 @@
-import type { Settings, Metadatas, Layouts } from '../../../shared/contracts/content-types';
-export type ConfigurationUpdate = {
-    settings: Settings;
-    metadatas: Metadatas;
-    layouts: Layouts;
-    options?: Record<string, unknown>;
-};
-declare const _default: ({ isComponent, prefix, storeUtils, getModels, }: {
-    isComponent?: boolean;
-    prefix: string;
-    storeUtils: any;
-    getModels: any;
-}) => {
-    getConfiguration: (uid: string) => any;
-    setConfiguration: (uid: string, input: ConfigurationUpdate) => any;
-    deleteConfiguration: (uid: string) => any;
-    syncConfigurations: () => Promise<void>;
-};
-export default _default;
-//# sourceMappingURL=configuration.d.ts.map

package/dist/server/src/services/configuration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"configuration.d.ts","sourceRoot":"","sources":["../../../../server/src/services/configuration.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAI5F,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,CAAC;0EAOC;IACD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,GAAG,CAAC;IAChB,SAAS,EAAE,GAAG,CAAC;CAChB;4BAKgC,MAAM;4BAMN,MAAM,SAAS,mBAAmB;+BAW/B,MAAM;;;AAhC1C,wBA8EE"}

package/dist/server/src/services/content-types.d.ts

@@ -1,18 +0,0 @@
-import type { UID, Struct, Core } from '@strapi/types';
-import type { ConfigurationUpdate } from './configuration';
-declare const service: ({ strapi }: {
-    strapi: Core.Strapi;
-}) => {
-    findAllContentTypes(): unknown[];
-    findContentType(uid: UID.ContentType): any;
-    findDisplayedContentTypes(): unknown[];
-    findContentTypesByKind(kind: {
-        kind: Struct.ContentTypeKind | undefined;
-    }): unknown[];
-    findConfiguration(contentType: Struct.ContentTypeSchema): Promise<any>;
-    updateConfiguration(contentType: Struct.ContentTypeSchema, newConfiguration: ConfigurationUpdate): Promise<any>;
-    findComponentsConfigurations(contentType: Struct.ContentTypeSchema): any;
-    syncConfigurations(): Promise<void>;
-};
-export default service;
-//# sourceMappingURL=content-types.d.ts.map

package/dist/server/src/services/content-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"content-types.d.ts","sourceRoot":"","sources":["../../../../server/src/services/content-types.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAEvD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAgB3D,QAAA,MAAM,OAAO,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;yBAO7B,IAAI,WAAW;;iCAgBP;QAAE,IAAI,EAAE,OAAO,eAAe,GAAG,SAAS,CAAA;KAAE;mCASpC,OAAO,iBAAiB;qCAU9C,OAAO,iBAAiB,oBACnB,mBAAmB;8CAOG,OAAO,iBAAiB;;CAQlE,CAAC;AAEH,eAAe,OAAO,CAAC"}

package/dist/server/src/services/data-mapper.d.ts

@@ -1,20 +0,0 @@
-import type { Struct } from '@strapi/types';
-declare const _default: () => {
-    toContentManagerModel(contentType: Struct.ComponentSchema): {
-        apiID: string;
-        isDisplayed: boolean;
-        attributes: any;
-        modelType: "component";
-        uid: `${string}.${string}`;
-        category: string;
-        modelName: string;
-        globalId: string;
-        pluginOptions?: Struct.SchemaPluginOptions | undefined;
-        options?: Struct.SchemaOptions | undefined;
-        collectionName?: string | undefined;
-        info: Struct.SchemaInfo;
-    };
-    toDto: import("lodash/fp").LodashPick2x1;
-};
-export default _default;
-//# sourceMappingURL=data-mapper.d.ts.map

package/dist/server/src/services/data-mapper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-mapper.d.ts","sourceRoot":"","sources":["../../../../server/src/services/data-mapper.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAU,MAAM,EAAE,MAAM,eAAe,CAAC;;uCAgBf,OAAO,eAAe;;;;;;;;;;;;;;;;AAD3D,wBAgBG"}