@strapi/content-manager 0.0.0 → 5.0.0-beta.10

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

@@ -0,0 +1,353 @@
+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[], validatableFields?: string[]): Promise<import("../../shared/contracts/collection-types").AvailableLocaleDocument[]>;
+            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<import("../../shared/contracts/collection-types").AvailableStatusDocument[]>;
+            getStatus(version: import("./services/document-metadata").DocumentVersion, otherDocumentStatuses?: import("../../shared/contracts/collection-types").AvailableStatusDocument[] | 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: import("../../shared/contracts/collection-types").AvailableLocaleDocument[];
+                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: number;
+                    documentId: string;
+                    locale: string;
+                    updatedAt: string | Date | null;
+                    publishedAt: string | Date | null;
+                };
+                meta: {
+                    availableLocales: import("../../shared/contracts/collection-types").AvailableLocaleDocument[];
+                    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 | 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;
+                isPublished?: boolean | 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: import("@strapi/utils/dist/pagination").PagePatinationInformation;
+            }>;
+            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(documentIds: string[], uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, opts?: (import("@strapi/types/dist/modules/documents/params/document-engine").FindMany<import("@strapi/types/dist/uid").ContentType> | undefined) & {
+                locale?: string | undefined;
+            }): 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[]>;
+            publishMany(uid: import("@strapi/types/dist/uid").ContentType, documentIds: string[], locale?: string | string[] | undefined): Promise<number>;
+            unpublishMany(documentIds: 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<{
+                count: number;
+            }>;
+            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(documentIds: string[], uid: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`, locale: string | 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

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

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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,9 @@
+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

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

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1 @@
+{"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"}