@strapi/content-manager 0.0.0-experimental.0581774d9b26d449a40191b96482efca5664a181

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

@@ -0,0 +1,354 @@
+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[]): 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<any[]>;
+            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: string | number;
+                    documentId: string;
+                    locale?: string | undefined;
+                    localizations?: import("./services/document-metadata").DocumentVersion[] | undefined;
+                    updatedAt?: string | Date | null | undefined;
+                    publishedAt?: string | Date | null | undefined;
+                };
+                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,wBAqBG"}

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/preview/controllers/index.d.ts

@@ -0,0 +1,2 @@
+export declare const controllers: Record<string, import("@strapi/types/dist/core").Controller>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../server/src/preview/controllers/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,8DAM0B,CAAC"}

package/dist/server/src/preview/controllers/preview.d.ts

@@ -0,0 +1,13 @@
+declare const createPreviewController: () => {
+    /**
+     * Transforms an entry into a preview URL, so that it can be previewed
+     * in the Content Manager.
+     */
+    getPreviewUrl(ctx: import("koa").Context): Promise<{
+        data: {
+            url: string | undefined;
+        };
+    }>;
+};
+export { createPreviewController };
+//# sourceMappingURL=preview.d.ts.map

package/dist/server/src/preview/controllers/preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../../../../server/src/preview/controllers/preview.ts"],"names":[],"mappings":"AAOA,QAAA,MAAM,uBAAuB;IAEzB;;;OAGG;;;;;;CAwBN,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/server/src/preview/controllers/validation/preview.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import type { Core, UID } from '@strapi/types';
+import { Preview } from '../../../../../shared/contracts';
+import type { HandlerParams } from '../../services/preview-config';
+export declare const validatePreviewUrl: (strapi: Core.Strapi, uid: UID.ContentType, params: Preview.GetPreviewUrl.Request['query']) => Promise<HandlerParams>;
+//# sourceMappingURL=preview.d.ts.map

package/dist/server/src/preview/controllers/validation/preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../../../../../server/src/preview/controllers/validation/preview.ts"],"names":[],"mappings":";AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAG/C,OAAO,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAYnE,eAAO,MAAM,kBAAkB,WACrB,KAAK,MAAM,OACd,IAAI,WAAW,UACZ,QAAQ,aAAa,QAAQ,CAAC,OAAO,CAAC,KAC7C,QAAQ,aAAa,CAwCvB,CAAC"}

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

@@ -0,0 +1,4 @@
+import type { Plugin } from '@strapi/types';
+declare const _default: Partial<Plugin.LoadedPlugin>;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * The routes will be merged with the other Content Manager routers,
+ * so we need to avoid conficts in the router name, and to prefix the path for each route.
+ */
+export declare const routes: {
+    preview: import("@strapi/types/dist/core").Router;
+};
+//# sourceMappingURL=index.d.ts.map

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+export declare const services: {
+    preview: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        getPreviewUrl(uid: import("@strapi/types/dist/uid").ContentType, params: import("./preview-config").HandlerParams): Promise<string | undefined>;
+    };
+    'preview-config': ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        register(): void;
+        isEnabled(): boolean;
+        validate(): void;
+        getPreviewHandler(): (uid: import("@strapi/types/dist/uid").Schema, params: import("./preview-config").HandlerParams) => string | undefined;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../server/src/preview/services/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;CAGsB,CAAC"}

package/dist/server/src/preview/services/preview-config.d.ts

@@ -0,0 +1,32 @@
+import type { Core, UID } from '@strapi/types';
+export type HandlerParams = {
+    documentId: string;
+    locale: string;
+    status: 'published' | 'draft';
+};
+export interface PreviewConfig {
+    enabled: boolean;
+    config: {
+        allowedOrigins: string[];
+        handler: (uid: UID.Schema, params: HandlerParams) => string | undefined;
+    };
+}
+/**
+ * Read configuration for static preview
+ */
+declare const createPreviewConfigService: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    register(): void;
+    isEnabled(): boolean;
+    /**
+     * Validate if the configuration is valid
+     */
+    validate(): void;
+    /**
+     * Utility to get the preview handler from the configuration
+     */
+    getPreviewHandler(): PreviewConfig['config']['handler'];
+};
+export { createPreviewConfigService };
+//# sourceMappingURL=preview-config.d.ts.map

package/dist/server/src/preview/services/preview-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-config.d.ts","sourceRoot":"","sources":["../../../../../server/src/preview/services/preview-config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAG/C,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC;CAC/B,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE;QAEN,cAAc,EAAE,MAAM,EAAE,CAAC;QACzB,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,KAAK,MAAM,GAAG,SAAS,CAAC;KACzE,CAAC;CACH;AAoCD;;GAEG;AACH,QAAA,MAAM,0BAA0B,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;;IAoCnE;;OAEG;;IAgBH;;OAEG;yBACkB,aAAa,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC;CAc1D,CAAC;AAEF,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

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

@@ -0,0 +1,12 @@
+import type { Core, UID } from '@strapi/types';
+import type { HandlerParams } from './preview-config';
+/**
+ * Responsible of routing an entry to a preview URL.
+ */
+declare const createPreviewService: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getPreviewUrl(uid: UID.ContentType, params: HandlerParams): Promise<string | undefined>;
+};
+export { createPreviewService };
+//# sourceMappingURL=preview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../../../../server/src/preview/services/preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAI/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD;;GAEG;AACH,QAAA,MAAM,oBAAoB,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;uBAIpC,IAAI,WAAW,UAAU,aAAa;CAelE,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/server/src/preview/utils.d.ts

@@ -0,0 +1,19 @@
+import type { Core } from '@strapi/types';
+type PreviewServices = typeof import('./services').services;
+declare function getService<T extends keyof PreviewServices>(strapi: Core.Strapi, name: T): ReturnType<{
+    preview: ({ strapi }: {
+        strapi: Core.Strapi;
+    }) => {
+        getPreviewUrl(uid: import("@strapi/types/dist/uid").ContentType, params: import("./services/preview-config").HandlerParams): Promise<string | undefined>;
+    };
+    'preview-config': ({ strapi }: {
+        strapi: Core.Strapi;
+    }) => {
+        register(): void;
+        isEnabled(): boolean;
+        validate(): void;
+        getPreviewHandler(): (uid: import("@strapi/types/dist/uid").Schema, params: import("./services/preview-config").HandlerParams) => string | undefined;
+    };
+}[T]>;
+export { getService };
+//# sourceMappingURL=utils.d.ts.map

package/dist/server/src/preview/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../server/src/preview/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C,KAAK,eAAe,GAAG,cAAc,YAAY,EAAE,QAAQ,CAAC;AAE5D,iBAAS,UAAU,CAAC,CAAC,SAAS,MAAM,eAAe,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC;;;;;;;;;;;;;;MAGhF;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

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;AAI5C,QAAA,MAAM,QAAQ,EAAE,MAAM,CAAC,YAAY,CAAC,UAAU,CAG7C,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"}