npm - payload - Versions diffs - 2.0.0-beta.0 → 2.0.0-beta.10 - Mend

payload 2.0.0-beta.0 → 2.0.0-beta.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1947) hide show

package/dist/collections/config/schema.js CHANGED Viewed

@@ -64,6 +64,15 @@ const collectionSchema = _joi.default.object().keys({
             beforeDuplicate: _joi.default.func()
         }),
         listSearchableFields: _joi.default.array().items(_joi.default.string()),
+        livePreview: _joi.default.object({
+            breakpoints: _joi.default.array().items(_joi.default.object({
+                name: _joi.default.string(),
+                height: _joi.default.alternatives().try(_joi.default.number(), _joi.default.string()),
+                label: _joi.default.string(),
+                width: _joi.default.alternatives().try(_joi.default.number(), _joi.default.string())
+            })),
+            url: _joi.default.string()
+        }),
         pagination: _joi.default.object({
             defaultLimit: _joi.default.number(),
             limits: _joi.default.array().items(_joi.default.number())
@@ -188,4 +197,4 @@ const collectionSchema = _joi.default.object().keys({
 });
 const _default = collectionSchema;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/collections/config/schema.ts"],"sourcesContent":["import joi from 'joi'\n\nimport { endpointsSchema } from '../../config/schema'\nimport { componentSchema, customViewSchema } from '../../config/shared/componentSchema'\n\nconst strategyBaseSchema = joi.object().keys({\n  logout: joi.boolean(),\n  refresh: joi.boolean(),\n})\n\nconst collectionSchema = joi.object().keys({\n  access: joi.object({\n    admin: joi.func(),\n    create: joi.func(),\n    delete: joi.func(),\n    read: joi.func(),\n    readVersions: joi.func(),\n    unlock: joi.func(),\n    update: joi.func(),\n  }),\n  admin: joi.object({\n    components: joi.object({\n      AfterList: joi.array().items(componentSchema),\n      AfterListTable: joi.array().items(componentSchema),\n      BeforeList: joi.array().items(componentSchema),\n      BeforeListTable: joi.array().items(componentSchema),\n      edit: joi.object({\n        PreviewButton: componentSchema,\n        PublishButton: componentSchema,\n        SaveButton: componentSchema,\n        SaveDraftButton: componentSchema,\n      }),\n      views: joi.object({\n        Edit: joi.alternatives().try(\n          componentSchema,\n          joi.object({\n            Default: joi.alternatives().try(componentSchema, customViewSchema),\n            Versions: joi.alternatives().try(componentSchema, customViewSchema),\n            // Version\n            // Preview\n            // Relationships\n            // References\n            // API\n            // :path\n          }),\n        ),\n        List: componentSchema,\n      }),\n    }),\n    defaultColumns: joi.array().items(joi.string()),\n    description: joi.alternatives().try(joi.string(), componentSchema),\n    disableDuplicate: joi.bool(),\n    enableRichTextLink: joi.boolean(),\n    enableRichTextRelationship: joi.boolean(),\n    group: joi.alternatives().try(joi.string(), joi.object().pattern(joi.string(), [joi.string()])),\n    hidden: joi.alternatives().try(joi.boolean(), joi.func()),\n    hideAPIURL: joi.bool(),\n    hooks: joi.object({\n      beforeDuplicate: joi.func(),\n    }),\n    listSearchableFields: joi.array().items(joi.string()),\n    pagination: joi.object({\n      defaultLimit: joi.number(),\n      limits: joi.array().items(joi.number()),\n    }),\n    preview: joi.func(),\n    useAsTitle: joi.string(),\n  }),\n  auth: joi.alternatives().try(\n    joi.object({\n      cookies: joi.object().keys({\n        domain: joi.string(),\n        sameSite: joi.string(), // TODO: add further specificity with joi.xor\n        secure: joi.boolean(),\n      }),\n      depth: joi.number(),\n      disableLocalStrategy: joi.boolean().valid(true),\n      forgotPassword: joi.object().keys({\n        generateEmailHTML: joi.func(),\n        generateEmailSubject: joi.func(),\n      }),\n      lockTime: joi.number(),\n      maxLoginAttempts: joi.number(),\n      removeTokenFromResponses: joi.boolean().valid(true),\n      strategies: joi.array().items(\n        joi.alternatives().try(\n          strategyBaseSchema.keys({\n            name: joi.string().required(),\n            strategy: joi.func().maxArity(1).required(),\n          }),\n          strategyBaseSchema.keys({\n            name: joi.string(),\n            strategy: joi.object().required(),\n          }),\n        ),\n      ),\n      tokenExpiration: joi.number(),\n      useAPIKey: joi.boolean(),\n      verify: joi.alternatives().try(\n        joi.boolean(),\n        joi.object().keys({\n          generateEmailHTML: joi.func(),\n          generateEmailSubject: joi.func(),\n        }),\n      ),\n    }),\n    joi.boolean(),\n  ),\n  custom: joi.object().pattern(joi.string(), joi.any()),\n  defaultSort: joi.string(),\n  endpoints: endpointsSchema,\n  fields: joi.array(),\n  graphQL: joi.alternatives().try(\n    joi.object().keys({\n      pluralName: joi.string(),\n      singularName: joi.string(),\n    }),\n    joi.boolean(),\n  ),\n  hooks: joi.object({\n    afterChange: joi.array().items(joi.func()),\n    afterDelete: joi.array().items(joi.func()),\n    afterForgotPassword: joi.array().items(joi.func()),\n    afterLogin: joi.array().items(joi.func()),\n    afterLogout: joi.array().items(joi.func()),\n    afterMe: joi.array().items(joi.func()),\n    afterOperation: joi.array().items(joi.func()),\n    afterRead: joi.array().items(joi.func()),\n    afterRefresh: joi.array().items(joi.func()),\n    beforeChange: joi.array().items(joi.func()),\n    beforeDelete: joi.array().items(joi.func()),\n    beforeLogin: joi.array().items(joi.func()),\n    beforeOperation: joi.array().items(joi.func()),\n    beforeRead: joi.array().items(joi.func()),\n    beforeValidate: joi.array().items(joi.func()),\n  }),\n  indexes: joi.array().items(\n    joi.object().keys({\n      fields: joi.object().required(),\n      options: joi.object(),\n    }),\n  ),\n  labels: joi.object({\n    plural: joi\n      .alternatives()\n      .try(joi.string(), joi.object().pattern(joi.string(), [joi.string()])),\n    singular: joi\n      .alternatives()\n      .try(joi.string(), joi.object().pattern(joi.string(), [joi.string()])),\n  }),\n  slug: joi.string().required(),\n  timestamps: joi.boolean(),\n  typescript: joi.object().keys({\n    interface: joi.string(),\n  }),\n  upload: joi.alternatives().try(\n    joi.object({\n      adminThumbnail: joi.alternatives().try(joi.string(), joi.func()),\n      disableLocalStorage: joi.bool(),\n      formatOptions: joi.object().keys({\n        format: joi.string(),\n        options: joi.object(),\n      }),\n      handlers: joi.array().items(joi.func()),\n      imageSizes: joi.array().items(\n        joi\n          .object()\n          .keys({\n            name: joi.string(),\n            crop: joi.string(), // TODO: add further specificity with joi.xor\n            height: joi.number().integer().allow(null),\n            width: joi.number().integer().allow(null),\n          })\n          .unknown(),\n      ),\n      mimeTypes: joi.array().items(joi.string()),\n      resizeOptions: joi\n        .object()\n        .keys({\n          background: joi.string(),\n          fastShrinkOnLoad: joi.bool(),\n          fit: joi.string(),\n          height: joi.number().allow(null),\n          kernel: joi.string(),\n          position: joi.alternatives().try(joi.string(), joi.number()),\n          width: joi.number().allow(null),\n          withoutEnlargement: joi.bool(),\n        })\n        .allow(null),\n      staticDir: joi.string(),\n      staticOptions: joi.object(),\n      staticURL: joi.string(),\n      tempFileDir: joi.string(),\n      trimOptions: joi.alternatives().try(\n        joi.object().keys({\n          format: joi.string(),\n          options: joi.object(),\n        }),\n        joi.string(),\n        joi.number(),\n      ),\n      useTempFiles: joi.bool(),\n    }),\n    joi.boolean(),\n  ),\n  versions: joi.alternatives().try(\n    joi.object({\n      drafts: joi.alternatives().try(\n        joi.object({\n          autosave: joi.alternatives().try(\n            joi.boolean(),\n            joi.object({\n              interval: joi.number(),\n            }),\n          ),\n        }),\n        joi.boolean(),\n      ),\n      maxPerDoc: joi.number(),\n    }),\n    joi.boolean(),\n  ),\n})\n\nexport default collectionSchema\n"],"names":["strategyBaseSchema","joi","object","keys","logout","boolean","refresh","collectionSchema","access","admin","func","create","delete","read","readVersions","unlock","update","components","AfterList","array","items","componentSchema","AfterListTable","BeforeList","BeforeListTable","edit","PreviewButton","PublishButton","SaveButton","SaveDraftButton","views","Edit","alternatives","try","Default","customViewSchema","Versions","List","defaultColumns","string","description","disableDuplicate","bool","enableRichTextLink","enableRichTextRelationship","group","pattern","hidden","hideAPIURL","hooks","beforeDuplicate","listSearchableFields","pagination","defaultLimit","number","limits","preview","useAsTitle","auth","cookies","domain","sameSite","secure","depth","disableLocalStrategy","valid","forgotPassword","generateEmailHTML","generateEmailSubject","lockTime","maxLoginAttempts","removeTokenFromResponses","strategies","name","required","strategy","maxArity","tokenExpiration","useAPIKey","verify","custom","any","defaultSort","endpoints","endpointsSchema","fields","graphQL","pluralName","singularName","afterChange","afterDelete","afterForgotPassword","afterLogin","afterLogout","afterMe","afterOperation","afterRead","afterRefresh","beforeChange","beforeDelete","beforeLogin","beforeOperation","beforeRead","beforeValidate","indexes","options","labels","plural","singular","slug","timestamps","typescript","interface","upload","adminThumbnail","disableLocalStorage","formatOptions","format","handlers","imageSizes","crop","height","integer","allow","width","unknown","mimeTypes","resizeOptions","background","fastShrinkOnLoad","fit","kernel","position","withoutEnlargement","staticDir","staticOptions","staticURL","tempFileDir","trimOptions","useTempFiles","versions","drafts","autosave","interval","maxPerDoc"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/collections/config/schema.ts"],"sourcesContent":["import joi from 'joi'\n\nimport { endpointsSchema } from '../../config/schema'\nimport { componentSchema, customViewSchema } from '../../config/shared/componentSchema'\n\nconst strategyBaseSchema = joi.object().keys({\n  logout: joi.boolean(),\n  refresh: joi.boolean(),\n})\n\nconst collectionSchema = joi.object().keys({\n  access: joi.object({\n    admin: joi.func(),\n    create: joi.func(),\n    delete: joi.func(),\n    read: joi.func(),\n    readVersions: joi.func(),\n    unlock: joi.func(),\n    update: joi.func(),\n  }),\n  admin: joi.object({\n    components: joi.object({\n      AfterList: joi.array().items(componentSchema),\n      AfterListTable: joi.array().items(componentSchema),\n      BeforeList: joi.array().items(componentSchema),\n      BeforeListTable: joi.array().items(componentSchema),\n      edit: joi.object({\n        PreviewButton: componentSchema,\n        PublishButton: componentSchema,\n        SaveButton: componentSchema,\n        SaveDraftButton: componentSchema,\n      }),\n      views: joi.object({\n        Edit: joi.alternatives().try(\n          componentSchema,\n          joi.object({\n            Default: joi.alternatives().try(componentSchema, customViewSchema),\n            Versions: joi.alternatives().try(componentSchema, customViewSchema),\n            // Version\n            // Preview\n            // Relationships\n            // References\n            // API\n            // :path\n          }),\n        ),\n        List: componentSchema,\n      }),\n    }),\n    defaultColumns: joi.array().items(joi.string()),\n    description: joi.alternatives().try(joi.string(), componentSchema),\n    disableDuplicate: joi.bool(),\n    enableRichTextLink: joi.boolean(),\n    enableRichTextRelationship: joi.boolean(),\n    group: joi.alternatives().try(joi.string(), joi.object().pattern(joi.string(), [joi.string()])),\n    hidden: joi.alternatives().try(joi.boolean(), joi.func()),\n    hideAPIURL: joi.bool(),\n    hooks: joi.object({\n      beforeDuplicate: joi.func(),\n    }),\n    listSearchableFields: joi.array().items(joi.string()),\n    livePreview: joi.object({\n      breakpoints: joi.array().items(\n        joi.object({\n          name: joi.string(),\n          height: joi.alternatives().try(joi.number(), joi.string()),\n          label: joi.string(),\n          width: joi.alternatives().try(joi.number(), joi.string()),\n        }),\n      ),\n      url: joi.string(),\n    }),\n    pagination: joi.object({\n      defaultLimit: joi.number(),\n      limits: joi.array().items(joi.number()),\n    }),\n    preview: joi.func(),\n    useAsTitle: joi.string(),\n  }),\n  auth: joi.alternatives().try(\n    joi.object({\n      cookies: joi.object().keys({\n        domain: joi.string(),\n        sameSite: joi.string(), // TODO: add further specificity with joi.xor\n        secure: joi.boolean(),\n      }),\n      depth: joi.number(),\n      disableLocalStrategy: joi.boolean().valid(true),\n      forgotPassword: joi.object().keys({\n        generateEmailHTML: joi.func(),\n        generateEmailSubject: joi.func(),\n      }),\n      lockTime: joi.number(),\n      maxLoginAttempts: joi.number(),\n      removeTokenFromResponses: joi.boolean().valid(true),\n      strategies: joi.array().items(\n        joi.alternatives().try(\n          strategyBaseSchema.keys({\n            name: joi.string().required(),\n            strategy: joi.func().maxArity(1).required(),\n          }),\n          strategyBaseSchema.keys({\n            name: joi.string(),\n            strategy: joi.object().required(),\n          }),\n        ),\n      ),\n      tokenExpiration: joi.number(),\n      useAPIKey: joi.boolean(),\n      verify: joi.alternatives().try(\n        joi.boolean(),\n        joi.object().keys({\n          generateEmailHTML: joi.func(),\n          generateEmailSubject: joi.func(),\n        }),\n      ),\n    }),\n    joi.boolean(),\n  ),\n  custom: joi.object().pattern(joi.string(), joi.any()),\n  defaultSort: joi.string(),\n  endpoints: endpointsSchema,\n  fields: joi.array(),\n  graphQL: joi.alternatives().try(\n    joi.object().keys({\n      pluralName: joi.string(),\n      singularName: joi.string(),\n    }),\n    joi.boolean(),\n  ),\n  hooks: joi.object({\n    afterChange: joi.array().items(joi.func()),\n    afterDelete: joi.array().items(joi.func()),\n    afterForgotPassword: joi.array().items(joi.func()),\n    afterLogin: joi.array().items(joi.func()),\n    afterLogout: joi.array().items(joi.func()),\n    afterMe: joi.array().items(joi.func()),\n    afterOperation: joi.array().items(joi.func()),\n    afterRead: joi.array().items(joi.func()),\n    afterRefresh: joi.array().items(joi.func()),\n    beforeChange: joi.array().items(joi.func()),\n    beforeDelete: joi.array().items(joi.func()),\n    beforeLogin: joi.array().items(joi.func()),\n    beforeOperation: joi.array().items(joi.func()),\n    beforeRead: joi.array().items(joi.func()),\n    beforeValidate: joi.array().items(joi.func()),\n  }),\n  indexes: joi.array().items(\n    joi.object().keys({\n      fields: joi.object().required(),\n      options: joi.object(),\n    }),\n  ),\n  labels: joi.object({\n    plural: joi\n      .alternatives()\n      .try(joi.string(), joi.object().pattern(joi.string(), [joi.string()])),\n    singular: joi\n      .alternatives()\n      .try(joi.string(), joi.object().pattern(joi.string(), [joi.string()])),\n  }),\n  slug: joi.string().required(),\n  timestamps: joi.boolean(),\n  typescript: joi.object().keys({\n    interface: joi.string(),\n  }),\n  upload: joi.alternatives().try(\n    joi.object({\n      adminThumbnail: joi.alternatives().try(joi.string(), joi.func()),\n      disableLocalStorage: joi.bool(),\n      formatOptions: joi.object().keys({\n        format: joi.string(),\n        options: joi.object(),\n      }),\n      handlers: joi.array().items(joi.func()),\n      imageSizes: joi.array().items(\n        joi\n          .object()\n          .keys({\n            name: joi.string(),\n            crop: joi.string(), // TODO: add further specificity with joi.xor\n            height: joi.number().integer().allow(null),\n            width: joi.number().integer().allow(null),\n          })\n          .unknown(),\n      ),\n      mimeTypes: joi.array().items(joi.string()),\n      resizeOptions: joi\n        .object()\n        .keys({\n          background: joi.string(),\n          fastShrinkOnLoad: joi.bool(),\n          fit: joi.string(),\n          height: joi.number().allow(null),\n          kernel: joi.string(),\n          position: joi.alternatives().try(joi.string(), joi.number()),\n          width: joi.number().allow(null),\n          withoutEnlargement: joi.bool(),\n        })\n        .allow(null),\n      staticDir: joi.string(),\n      staticOptions: joi.object(),\n      staticURL: joi.string(),\n      tempFileDir: joi.string(),\n      trimOptions: joi.alternatives().try(\n        joi.object().keys({\n          format: joi.string(),\n          options: joi.object(),\n        }),\n        joi.string(),\n        joi.number(),\n      ),\n      useTempFiles: joi.bool(),\n    }),\n    joi.boolean(),\n  ),\n  versions: joi.alternatives().try(\n    joi.object({\n      drafts: joi.alternatives().try(\n        joi.object({\n          autosave: joi.alternatives().try(\n            joi.boolean(),\n            joi.object({\n              interval: joi.number(),\n            }),\n          ),\n        }),\n        joi.boolean(),\n      ),\n      maxPerDoc: joi.number(),\n    }),\n    joi.boolean(),\n  ),\n})\n\nexport default collectionSchema\n"],"names":["strategyBaseSchema","joi","object","keys","logout","boolean","refresh","collectionSchema","access","admin","func","create","delete","read","readVersions","unlock","update","components","AfterList","array","items","componentSchema","AfterListTable","BeforeList","BeforeListTable","edit","PreviewButton","PublishButton","SaveButton","SaveDraftButton","views","Edit","alternatives","try","Default","customViewSchema","Versions","List","defaultColumns","string","description","disableDuplicate","bool","enableRichTextLink","enableRichTextRelationship","group","pattern","hidden","hideAPIURL","hooks","beforeDuplicate","listSearchableFields","livePreview","breakpoints","name","height","number","label","width","url","pagination","defaultLimit","limits","preview","useAsTitle","auth","cookies","domain","sameSite","secure","depth","disableLocalStrategy","valid","forgotPassword","generateEmailHTML","generateEmailSubject","lockTime","maxLoginAttempts","removeTokenFromResponses","strategies","required","strategy","maxArity","tokenExpiration","useAPIKey","verify","custom","any","defaultSort","endpoints","endpointsSchema","fields","graphQL","pluralName","singularName","afterChange","afterDelete","afterForgotPassword","afterLogin","afterLogout","afterMe","afterOperation","afterRead","afterRefresh","beforeChange","beforeDelete","beforeLogin","beforeOperation","beforeRead","beforeValidate","indexes","options","labels","plural","singular","slug","timestamps","typescript","interface","upload","adminThumbnail","disableLocalStorage","formatOptions","format","handlers","imageSizes","crop","integer","allow","unknown","mimeTypes","resizeOptions","background","fastShrinkOnLoad","fit","kernel","position","withoutEnlargement","staticDir","staticOptions","staticURL","tempFileDir","trimOptions","useTempFiles","versions","drafts","autosave","interval","maxPerDoc"],"mappings":"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"}

package/dist/collections/config/types.d.ts ADDED Viewed

@@ -0,0 +1,422 @@
+/// <reference types="react" />
+import type { Response } from 'express';
+import type { GraphQLInputObjectType, GraphQLNonNull, GraphQLObjectType } from 'graphql';
+import type { DeepRequired } from 'ts-essentials';
+import type { GeneratedTypes } from '../../';
+import type { CustomPreviewButtonProps, CustomPublishButtonProps, CustomSaveButtonProps, CustomSaveDraftButtonProps } from '../../admin/components/elements/types';
+import type { Props as ListProps } from '../../admin/components/views/collections/List/types';
+import type { Auth, IncomingAuthType, User } from '../../auth/types';
+import type { Access, EditView, EditViewComponent, Endpoint, EntityDescription, GeneratePreviewURL, LivePreview } from '../../config/types';
+import type { PayloadRequest, RequestContext } from '../../express/types';
+import type { Field } from '../../fields/config/types';
+import type { IncomingUploadType, Upload } from '../../uploads/types';
+import type { IncomingCollectionVersions, SanitizedCollectionVersions } from '../../versions/types';
+import type { AfterOperationArg, AfterOperationMap } from '../operations/utils';
+export type HookOperationType = 'autosave' | 'create' | 'delete' | 'forgotPassword' | 'login' | 'read' | 'refresh' | 'update';
+type CreateOrUpdateOperation = Extract<HookOperationType, 'create' | 'update'>;
+export type BeforeOperationHook = (args: {
+    args?: any;
+    context: RequestContext;
+    /**
+     * Hook operation being performed
+     */
+    operation: HookOperationType;
+}) => any;
+export type BeforeValidateHook<T extends TypeWithID = any> = (args: {
+    context: RequestContext;
+    data?: Partial<T>;
+    /**
+     * Hook operation being performed
+     */
+    operation: CreateOrUpdateOperation;
+    /**
+     * Original document before change
+     *
+     * `undefined` on 'create' operation
+     */
+    originalDoc?: T;
+    req?: PayloadRequest;
+}) => any;
+export type BeforeChangeHook<T extends TypeWithID = any> = (args: {
+    context: RequestContext;
+    data: Partial<T>;
+    /**
+     * Hook operation being performed
+     */
+    operation: CreateOrUpdateOperation;
+    /**
+     * Original document before change
+     *
+     * `undefined` on 'create' operation
+     */
+    originalDoc?: T;
+    req: PayloadRequest;
+}) => any;
+export type AfterChangeHook<T extends TypeWithID = any> = (args: {
+    context: RequestContext;
+    doc: T;
+    /**
+     * Hook operation being performed
+     */
+    operation: CreateOrUpdateOperation;
+    previousDoc: T;
+    req: PayloadRequest;
+}) => any;
+export type BeforeReadHook<T extends TypeWithID = any> = (args: {
+    context: RequestContext;
+    doc: T;
+    query: {
+        [key: string]: any;
+    };
+    req: PayloadRequest;
+}) => any;
+export type AfterReadHook<T extends TypeWithID = any> = (args: {
+    context: RequestContext;
+    doc: T;
+    findMany?: boolean;
+    query?: {
+        [key: string]: any;
+    };
+    req: PayloadRequest;
+}) => any;
+export type BeforeDeleteHook = (args: {
+    context: RequestContext;
+    id: number | string;
+    req: PayloadRequest;
+}) => any;
+export type AfterDeleteHook<T extends TypeWithID = any> = (args: {
+    context: RequestContext;
+    doc: T;
+    id: number | string;
+    req: PayloadRequest;
+}) => any;
+export type AfterOperationHook<T extends TypeWithID = any> = (arg: AfterOperationArg<T>) => Promise<ReturnType<AfterOperationMap<T>[keyof AfterOperationMap<T>]>>;
+export type AfterErrorHook = (err: Error, res: unknown, context: RequestContext) => {
+    response: any;
+    status: number;
+} | void;
+export type BeforeLoginHook<T extends TypeWithID = any> = (args: {
+    context: RequestContext;
+    req: PayloadRequest;
+    user: T;
+}) => any;
+export type AfterLoginHook<T extends TypeWithID = any> = (args: {
+    context: RequestContext;
+    req: PayloadRequest;
+    token: string;
+    user: T;
+}) => any;
+export type AfterLogoutHook<T extends TypeWithID = any> = (args: {
+    context: RequestContext;
+    req: PayloadRequest;
+    res: Response;
+}) => any;
+export type AfterMeHook<T extends TypeWithID = any> = (args: {
+    context: RequestContext;
+    req: PayloadRequest;
+    response: unknown;
+}) => any;
+export type AfterRefreshHook<T extends TypeWithID = any> = (args: {
+    context: RequestContext;
+    exp: number;
+    req: PayloadRequest;
+    res: Response;
+    token: string;
+}) => any;
+export type AfterForgotPasswordHook = (args: {
+    args?: any;
+    context: RequestContext;
+}) => any;
+type BeforeDuplicateArgs<T> = {
+    data: T;
+    locale?: string;
+};
+export type BeforeDuplicate<T = any> = (args: BeforeDuplicateArgs<T>) => Promise<T> | T;
+export type CollectionAdminOptions = {
+    /**
+     * Custom admin components
+     */
+    components?: {
+        AfterList?: React.ComponentType<ListProps>[];
+        AfterListTable?: React.ComponentType<ListProps>[];
+        BeforeList?: React.ComponentType<ListProps>[];
+        BeforeListTable?: React.ComponentType<ListProps>[];
+        /**
+         * Components within the edit view
+         */
+        edit?: {
+            /**
+             * Replaces the "Preview" button
+             */
+            PreviewButton?: CustomPreviewButtonProps;
+            /**
+             * Replaces the "Publish" button
+             * + drafts must be enabled
+             */
+            PublishButton?: CustomPublishButtonProps;
+            /**
+             * Replaces the "Save" button
+             * + drafts must be disabled
+             */
+            SaveButton?: CustomSaveButtonProps;
+            /**
+             * Replaces the "Save Draft" button
+             * + drafts must be enabled
+             * + autosave must be disabled
+             */
+            SaveDraftButton?: CustomSaveDraftButtonProps;
+        };
+        views?: {
+            /**
+             * Set to a React component to replace the entire "Edit" view, including all nested routes.
+             * Set to an object to replace or modify individual nested routes, or to add new ones.
+             */
+            Edit?: {
+                [key: string]: EditView;
+                /**
+                 * Replace or modify individual nested routes, or add new ones:
+                 * + `Default` - `/admin/collections/:collection/:id`
+                 * + `API` - `/admin/collections/:collection/:id/api`
+                 * + `LivePreview` - `/admin/collections/:collection/:id/preview`
+                 * + `References` - `/admin/collections/:collection/:id/references`
+                 * + `Relationships` - `/admin/collections/:collection/:id/relationships`
+                 * + `Versions` - `/admin/collections/:collection/:id/versions`
+                 * + `Version` - `/admin/collections/:collection/:id/versions/:version`
+                 * + `:path` - `/admin/collections/:collection/:id/:path`
+                 */
+                Default?: EditView;
+                Versions?: EditView;
+            } | EditViewComponent;
+            List?: React.ComponentType<ListProps>;
+        };
+    };
+    /**
+     * Default columns to show in list view
+     */
+    defaultColumns?: string[];
+    /**
+     * Custom description for collection
+     */
+    description?: EntityDescription;
+    disableDuplicate?: boolean;
+    enableRichTextLink?: boolean;
+    enableRichTextRelationship?: boolean;
+    /**
+     * Place collections into a navigational group
+     * */
+    group?: Record<string, string> | string;
+    /**
+     * Exclude the collection from the admin nav and routes
+     */
+    hidden?: ((args: {
+        user: User;
+    }) => boolean) | boolean;
+    /**
+     * Hide the API URL within the Edit view
+     */
+    hideAPIURL?: boolean;
+    hooks?: {
+        /**
+         * Function that allows you to modify a document's data before it is duplicated
+         */
+        beforeDuplicate?: BeforeDuplicate;
+    };
+    /**
+     * Additional fields to be searched via the full text search
+     */
+    listSearchableFields?: string[];
+    /**
+     * Live preview options
+     */
+    livePreview?: LivePreview;
+    pagination?: {
+        defaultLimit?: number;
+        limits?: number[];
+    };
+    /**
+     * Function to generate custom preview URL
+     */
+    preview?: GeneratePreviewURL;
+    /**
+     * Field to use as title in Edit view and first column in List view
+     */
+    useAsTitle?: string;
+};
+/** Manage all aspects of a data collection */
+export type CollectionConfig = {
+    /**
+     * Access control
+     */
+    access?: {
+        admin?: (args?: any) => Promise<boolean> | boolean;
+        create?: Access;
+        delete?: Access;
+        read?: Access;
+        readVersions?: Access;
+        unlock?: Access;
+        update?: Access;
+    };
+    /**
+     * Collection admin options
+     */
+    admin?: CollectionAdminOptions;
+    /**
+     * Collection login options
+     *
+     * Use `true` to enable with default options
+     */
+    auth?: IncomingAuthType | boolean;
+    /** Extension point to add your custom data. */
+    custom?: Record<string, any>;
+    /**
+     * Default field to sort by in collection list view
+     */
+    defaultSort?: string;
+    /**
+     * Custom rest api endpoints, set false to disable all rest endpoints for this collection.
+     */
+    endpoints?: Omit<Endpoint, 'root'>[] | false;
+    fields: Field[];
+    /**
+     * GraphQL configuration
+     */
+    graphQL?: {
+        pluralName?: string;
+        singularName?: string;
+    } | false;
+    /**
+     * Hooks to modify Payload functionality
+     */
+    hooks?: {
+        afterChange?: AfterChangeHook[];
+        afterDelete?: AfterDeleteHook[];
+        afterError?: AfterErrorHook;
+        afterForgotPassword?: AfterForgotPasswordHook[];
+        afterLogin?: AfterLoginHook[];
+        afterLogout?: AfterLogoutHook[];
+        afterMe?: AfterMeHook[];
+        afterOperation?: AfterOperationHook[];
+        afterRead?: AfterReadHook[];
+        afterRefresh?: AfterRefreshHook[];
+        beforeChange?: BeforeChangeHook[];
+        beforeDelete?: BeforeDeleteHook[];
+        beforeLogin?: BeforeLoginHook[];
+        beforeOperation?: BeforeOperationHook[];
+        beforeRead?: BeforeReadHook[];
+        beforeValidate?: BeforeValidateHook[];
+    };
+    /**
+     * Array of database indexes to create, including compound indexes that have multiple fields
+     */
+    indexes?: TypeOfIndex[];
+    /**
+     * Label configuration
+     */
+    labels?: {
+        plural?: Record<string, string> | string;
+        singular?: Record<string, string> | string;
+    };
+    slug: string;
+    /**
+     * Add `createdAt` and `updatedAt` fields
+     *
+     * @default true
+     */
+    timestamps?: boolean;
+    /**
+     * Options used in typescript generation
+     */
+    typescript?: {
+        /**
+         * Typescript generation name given to the interface type
+         */
+        interface?: string;
+    };
+    /**
+     * Customize the handling of incoming file uploads
+     *
+     * @default false // disable uploads
+     */
+    upload?: IncomingUploadType | boolean;
+    /**
+     * Customize the handling of incoming file uploads
+     *
+     * @default false // disable versioning
+     */
+    versions?: IncomingCollectionVersions | boolean;
+};
+export interface SanitizedCollectionConfig extends Omit<DeepRequired<CollectionConfig>, 'auth' | 'endpoints' | 'fields' | 'upload' | 'versions'> {
+    auth: Auth;
+    endpoints: Omit<Endpoint, 'root'>[] | false;
+    fields: Field[];
+    upload: Upload;
+    versions: SanitizedCollectionVersions;
+}
+export type Collection = {
+    config: SanitizedCollectionConfig;
+    graphQL?: {
+        JWT: GraphQLObjectType;
+        mutationInputType: GraphQLNonNull<any>;
+        paginatedType: GraphQLObjectType;
+        type: GraphQLObjectType;
+        updateMutationInputType: GraphQLNonNull<any>;
+        versionType: GraphQLObjectType;
+        whereInputType: GraphQLInputObjectType;
+    };
+};
+export type BulkOperationResult<TSlug extends keyof GeneratedTypes['collections']> = {
+    docs: GeneratedTypes['collections'][TSlug][];
+    errors: {
+        id: GeneratedTypes['collections'][TSlug]['id'];
+        message: string;
+    }[];
+};
+export type AuthCollection = {
+    config: SanitizedCollectionConfig;
+};
+export type TypeWithID = {
+    id: number | string;
+};
+export type TypeWithTimestamps = {
+    [key: string]: unknown;
+    createdAt: string;
+    id: number | string;
+    updatedAt: string;
+};
+type IndexDirection = '2d' | '2dsphere' | 'asc' | 'ascending' | 'desc' | 'descending' | 'geoHaystack' | 'hashed' | 'text' | -1 | 1;
+type IndexOptions = {
+    '2dsphereIndexVersion'?: number;
+    /** Creates the index in the background, yielding whenever possible. */
+    background?: boolean;
+    bits?: number;
+    bucketSize?: number;
+    /** (MongoDB 4.4. or higher) Specifies how many data-bearing members of a replica set, including the primary, must complete the index builds successfully before the primary marks the indexes as ready. This option accepts the same values for the "w" field in a write concern plus "votingMembers", which indicates all voting data-bearing nodes. */
+    commitQuorum?: number | string;
+    default_language?: string;
+    /** Allows you to expire data on indexes applied to a data (MongoDB 2.2 or higher) */
+    expireAfterSeconds?: number;
+    expires?: number | string;
+    /** Specifies that the index should exist on the target collection but should not be used by the query planner when executing operations. (MongoDB 4.4 or higher) */
+    hidden?: boolean;
+    language_override?: string;
+    /** For geospatial indexes set the high bound for the co-ordinates. */
+    max?: number;
+    /** For geospatial indexes set the lower bound for the co-ordinates. */
+    min?: number;
+    /** Override the autogenerated index name (useful if the resulting name is larger than 128 bytes) */
+    name?: string;
+    /** Creates a sparse index. */
+    sparse?: boolean;
+    textIndexVersion?: number;
+    /** Creates an unique index. */
+    unique?: boolean;
+    /** Specifies the index version number, either 0 or 1. */
+    version?: number;
+    weights?: Record<string, number>;
+};
+export type TypeOfIndex = {
+    fields: Record<string, IndexDirection>;
+    options?: IndexOptions;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/collections/config/types.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/collections/config/types.ts"],"names":[],"mappings":"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"}

package/dist/collections/config/types.js CHANGED Viewed

@@ -3,4 +3,4 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/collections/config/types.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { Response } from 'express'\nimport type { GraphQLInputObjectType, GraphQLNonNull, GraphQLObjectType } from 'graphql'\nimport type { Config as GeneratedTypes } from 'payload/generated-types'\nimport type { DeepRequired } from 'ts-essentials'\n\nimport type {\n  CustomPreviewButtonProps,\n  CustomPublishButtonProps,\n  CustomSaveButtonProps,\n  CustomSaveDraftButtonProps,\n} from '../../admin/components/elements/types'\nimport type { Props as ListProps } from '../../admin/components/views/collections/List/types'\nimport type { Auth, IncomingAuthType, User } from '../../auth/types'\nimport type {\n  Access,\n  EditViewComponent,\n  Endpoint,\n  EntityDescription,\n  GeneratePreviewURL,\n} from '../../config/types'\nimport type { PayloadRequest, RequestContext } from '../../express/types'\nimport type { Field } from '../../fields/config/types'\nimport type { IncomingUploadType, Upload } from '../../uploads/types'\nimport type { IncomingCollectionVersions, SanitizedCollectionVersions } from '../../versions/types'\nimport type { AfterOperationArg, AfterOperationMap } from '../operations/utils'\nimport type { EditView } from '../../config/types'\n\nexport type HookOperationType =\n  | 'autosave'\n  | 'create'\n  | 'delete'\n  | 'forgotPassword'\n  | 'login'\n  | 'read'\n  | 'refresh'\n  | 'update'\n\ntype CreateOrUpdateOperation = Extract<HookOperationType, 'create' | 'update'>\n\nexport type BeforeOperationHook = (args: {\n  args?: any\n  context: RequestContext\n  /**\n   * Hook operation being performed\n   */\n  operation: HookOperationType\n}) => any\n\nexport type BeforeValidateHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  data?: Partial<T>\n  /**\n   * Hook operation being performed\n   */\n  operation: CreateOrUpdateOperation\n  /**\n   * Original document before change\n   *\n   * `undefined` on 'create' operation\n   */\n  originalDoc?: T\n  req?: PayloadRequest\n}) => any\n\nexport type BeforeChangeHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  data: Partial<T>\n  /**\n   * Hook operation being performed\n   */\n  operation: CreateOrUpdateOperation\n  /**\n   * Original document before change\n   *\n   * `undefined` on 'create' operation\n   */\n  originalDoc?: T\n  req: PayloadRequest\n}) => any\n\nexport type AfterChangeHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  doc: T\n  /**\n   * Hook operation being performed\n   */\n  operation: CreateOrUpdateOperation\n  previousDoc: T\n  req: PayloadRequest\n}) => any\n\nexport type BeforeReadHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  doc: T\n  query: { [key: string]: any }\n  req: PayloadRequest\n}) => any\n\nexport type AfterReadHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  doc: T\n  findMany?: boolean\n  query?: { [key: string]: any }\n  req: PayloadRequest\n}) => any\n\nexport type BeforeDeleteHook = (args: {\n  context: RequestContext\n  id: number | string\n  req: PayloadRequest\n}) => any\n\nexport type AfterDeleteHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  doc: T\n  id: number | string\n  req: PayloadRequest\n}) => any\n\nexport type AfterOperationHook<T extends TypeWithID = any> = (\n  arg: AfterOperationArg<T>,\n) => Promise<ReturnType<AfterOperationMap<T>[keyof AfterOperationMap<T>]>>\n\nexport type AfterErrorHook = (\n  err: Error,\n  res: unknown,\n  context: RequestContext,\n) => { response: any; status: number } | void\n\nexport type BeforeLoginHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  req: PayloadRequest\n  user: T\n}) => any\n\nexport type AfterLoginHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  req: PayloadRequest\n  token: string\n  user: T\n}) => any\n\nexport type AfterLogoutHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  req: PayloadRequest\n  res: Response\n}) => any\n\nexport type AfterMeHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  req: PayloadRequest\n  response: unknown\n}) => any\n\nexport type AfterRefreshHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  exp: number\n  req: PayloadRequest\n  res: Response\n  token: string\n}) => any\n\nexport type AfterForgotPasswordHook = (args: { args?: any; context: RequestContext }) => any\n\ntype BeforeDuplicateArgs<T> = {\n  data: T\n  locale?: string\n}\n\nexport type BeforeDuplicate<T = any> = (args: BeforeDuplicateArgs<T>) => Promise<T> | T\n\nexport type CollectionAdminOptions = {\n  /**\n   * Custom admin components\n   */\n  components?: {\n    AfterList?: React.ComponentType<ListProps>[]\n    AfterListTable?: React.ComponentType<ListProps>[]\n    BeforeList?: React.ComponentType<ListProps>[]\n    BeforeListTable?: React.ComponentType<ListProps>[]\n    /**\n     * Components within the edit view\n     */\n    edit?: {\n      /**\n       * Replaces the \"Preview\" button\n       */\n      PreviewButton?: CustomPreviewButtonProps\n      /**\n       * Replaces the \"Publish\" button\n       * + drafts must be enabled\n       */\n      PublishButton?: CustomPublishButtonProps\n      /**\n       * Replaces the \"Save\" button\n       * + drafts must be disabled\n       */\n      SaveButton?: CustomSaveButtonProps\n      /**\n       * Replaces the \"Save Draft\" button\n       * + drafts must be enabled\n       * + autosave must be disabled\n       */\n      SaveDraftButton?: CustomSaveDraftButtonProps\n    }\n    views?: {\n      /**\n       * Set to a React component to replace the entire \"Edit\" view, including all nested routes.\n       * Set to an object to replace or modify individual nested routes, or to add new ones.\n       */\n      Edit?:\n        | {\n            /**\n             * Replace or modify individual nested routes, or add new ones:\n             * + `Default` - `/admin/collections/:collection/:id`\n             * + `API` - `/admin/collections/:collection/:id/api`\n             * + `LivePreview` - `/admin/collections/:collection/:id/preview`\n             * + `References` - `/admin/collections/:collection/:id/references`\n             * + `Relationships` - `/admin/collections/:collection/:id/relationships`\n             * + `Versions` - `/admin/collections/:collection/:id/versions`\n             * + `Version` - `/admin/collections/:collection/:id/versions/:version`\n             * + `:path` - `/admin/collections/:collection/:id/:path`\n             */\n            Default?: EditView\n            Versions?: EditView\n            [key: string]: EditView\n            // TODO: uncomment these as they are built\n            // API?: EditView\n            // LivePreview?: EditView\n            // References?: EditView\n            // Relationships?: EditView\n            // Version: EditView\n          }\n        | EditViewComponent\n      List?: React.ComponentType<ListProps>\n    }\n  }\n  /**\n   * Default columns to show in list view\n   */\n  defaultColumns?: string[]\n  /**\n   * Custom description for collection\n   */\n  description?: EntityDescription\n  disableDuplicate?: boolean\n  enableRichTextLink?: boolean\n  enableRichTextRelationship?: boolean\n  /**\n   * Place collections into a navigational group\n   * */\n  group?: Record<string, string> | string\n  /**\n   * Exclude the collection from the admin nav and routes\n   */\n  hidden?: ((args: { user: User }) => boolean) | boolean\n  /**\n   * Hide the API URL within the Edit view\n   */\n  hideAPIURL?: boolean\n  hooks?: {\n    /**\n     * Function that allows you to modify a document's data before it is duplicated\n     */\n    beforeDuplicate?: BeforeDuplicate\n  }\n  /**\n   * Additional fields to be searched via the full text search\n   */\n  listSearchableFields?: string[]\n  pagination?: {\n    defaultLimit?: number\n    limits?: number[]\n  }\n  /**\n   * Function to generate custom preview URL\n   */\n  preview?: GeneratePreviewURL\n  /**\n   * Field to use as title in Edit view and first column in List view\n   */\n  useAsTitle?: string\n}\n\n/** Manage all aspects of a data collection */\nexport type CollectionConfig = {\n  /**\n   * Access control\n   */\n  access?: {\n    admin?: (args?: any) => Promise<boolean> | boolean\n    create?: Access\n    delete?: Access\n    read?: Access\n    readVersions?: Access\n    unlock?: Access\n    update?: Access\n  }\n  /**\n   * Collection admin options\n   */\n  admin?: CollectionAdminOptions\n  /**\n   * Collection login options\n   *\n   * Use `true` to enable with default options\n   */\n  auth?: IncomingAuthType | boolean\n  /** Extension point to add your custom data. */\n  custom?: Record<string, any>\n  /**\n   * Default field to sort by in collection list view\n   */\n  defaultSort?: string\n  /**\n   * Custom rest api endpoints, set false to disable all rest endpoints for this collection.\n   */\n  endpoints?: Omit<Endpoint, 'root'>[] | false\n  fields: Field[]\n  /**\n   * GraphQL configuration\n   */\n  graphQL?:\n    | {\n        pluralName?: string\n        singularName?: string\n      }\n    | false\n  /**\n   * Hooks to modify Payload functionality\n   */\n  hooks?: {\n    afterChange?: AfterChangeHook[]\n    afterDelete?: AfterDeleteHook[]\n    afterError?: AfterErrorHook\n    afterForgotPassword?: AfterForgotPasswordHook[]\n    afterLogin?: AfterLoginHook[]\n    afterLogout?: AfterLogoutHook[]\n    afterMe?: AfterMeHook[]\n    afterOperation?: AfterOperationHook[]\n    afterRead?: AfterReadHook[]\n    afterRefresh?: AfterRefreshHook[]\n    beforeChange?: BeforeChangeHook[]\n    beforeDelete?: BeforeDeleteHook[]\n    beforeLogin?: BeforeLoginHook[]\n    beforeOperation?: BeforeOperationHook[]\n    beforeRead?: BeforeReadHook[]\n    beforeValidate?: BeforeValidateHook[]\n  }\n  /**\n   * Array of database indexes to create, including compound indexes that have multiple fields\n   */\n  indexes?: TypeOfIndex[]\n  /**\n   * Label configuration\n   */\n  labels?: {\n    plural?: Record<string, string> | string\n    singular?: Record<string, string> | string\n  }\n  slug: string\n  /**\n   * Add `createdAt` and `updatedAt` fields\n   *\n   * @default true\n   */\n  timestamps?: boolean\n  /**\n   * Options used in typescript generation\n   */\n  typescript?: {\n    /**\n     * Typescript generation name given to the interface type\n     */\n    interface?: string\n  }\n  /**\n   * Customize the handling of incoming file uploads\n   *\n   * @default false // disable uploads\n   */\n  upload?: IncomingUploadType | boolean\n  /**\n   * Customize the handling of incoming file uploads\n   *\n   * @default false // disable versioning\n   */\n  versions?: IncomingCollectionVersions | boolean\n}\n\nexport interface SanitizedCollectionConfig\n  extends Omit<\n    DeepRequired<CollectionConfig>,\n    'auth' | 'endpoints' | 'fields' | 'upload' | 'versions'\n  > {\n  auth: Auth\n  endpoints: Omit<Endpoint, 'root'>[] | false\n  fields: Field[]\n  upload: Upload\n  versions: SanitizedCollectionVersions\n}\n\nexport type Collection = {\n  config: SanitizedCollectionConfig\n  graphQL?: {\n    JWT: GraphQLObjectType\n    mutationInputType: GraphQLNonNull<any>\n    paginatedType: GraphQLObjectType\n    type: GraphQLObjectType\n    updateMutationInputType: GraphQLNonNull<any>\n    versionType: GraphQLObjectType\n    whereInputType: GraphQLInputObjectType\n  }\n}\n\nexport type BulkOperationResult<TSlug extends keyof GeneratedTypes['collections']> = {\n  docs: GeneratedTypes['collections'][TSlug][]\n  errors: {\n    id: GeneratedTypes['collections'][TSlug]['id']\n    message: string\n  }[]\n}\n\nexport type AuthCollection = {\n  config: SanitizedCollectionConfig\n}\n\nexport type TypeWithID = {\n  id: number | string\n}\n\nexport type TypeWithTimestamps = {\n  [key: string]: unknown\n  createdAt: string\n  id: number | string\n  updatedAt: string\n}\n\ntype IndexDirection =\n  | '2d'\n  | '2dsphere'\n  | 'asc'\n  | 'ascending'\n  | 'desc'\n  | 'descending'\n  | 'geoHaystack'\n  | 'hashed'\n  | 'text'\n  | -1\n  | 1\n\ntype IndexOptions = {\n  '2dsphereIndexVersion'?: number\n  /** Creates the index in the background, yielding whenever possible. */\n  background?: boolean\n  bits?: number\n  bucketSize?: number\n  /** (MongoDB 4.4. or higher) Specifies how many data-bearing members of a replica set, including the primary, must complete the index builds successfully before the primary marks the indexes as ready. This option accepts the same values for the \"w\" field in a write concern plus \"votingMembers\", which indicates all voting data-bearing nodes. */\n  commitQuorum?: number | string\n  default_language?: string\n  /** Allows you to expire data on indexes applied to a data (MongoDB 2.2 or higher) */\n  expireAfterSeconds?: number\n  expires?: number | string\n  /** Specifies that the index should exist on the target collection but should not be used by the query planner when executing operations. (MongoDB 4.4 or higher) */\n  hidden?: boolean\n  language_override?: string\n  /** For geospatial indexes set the high bound for the co-ordinates. */\n  max?: number\n  /** For geospatial indexes set the lower bound for the co-ordinates. */\n  min?: number\n  /** Override the autogenerated index name (useful if the resulting name is larger than 128 bytes) */\n  name?: string\n  /** Creates a sparse index. */\n  sparse?: boolean\n  textIndexVersion?: number\n  /** Creates an unique index. */\n  unique?: boolean\n  /** Specifies the index version number, either 0 or 1. */\n  version?: number\n  weights?: Record<string, number>\n}\n\nexport type TypeOfIndex = {\n  fields: Record<string, IndexDirection>\n  options?: IndexOptions\n}\n"],"names":[],"mappings":"AAAA,qDAAqD"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/collections/config/types.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { Response } from 'express'\nimport type { GraphQLInputObjectType, GraphQLNonNull, GraphQLObjectType } from 'graphql'\nimport type { DeepRequired } from 'ts-essentials'\n\nimport type { GeneratedTypes } from '../../'\nimport type {\n  CustomPreviewButtonProps,\n  CustomPublishButtonProps,\n  CustomSaveButtonProps,\n  CustomSaveDraftButtonProps,\n} from '../../admin/components/elements/types'\nimport type { Props as ListProps } from '../../admin/components/views/collections/List/types'\nimport type { Auth, IncomingAuthType, User } from '../../auth/types'\nimport type {\n  Access,\n  EditView,\n  EditViewComponent,\n  Endpoint,\n  EntityDescription,\n  GeneratePreviewURL,\n  LivePreview,\n} from '../../config/types'\nimport type { PayloadRequest, RequestContext } from '../../express/types'\nimport type { Field } from '../../fields/config/types'\nimport type { IncomingUploadType, Upload } from '../../uploads/types'\nimport type { IncomingCollectionVersions, SanitizedCollectionVersions } from '../../versions/types'\nimport type { AfterOperationArg, AfterOperationMap } from '../operations/utils'\n\nexport type HookOperationType =\n  | 'autosave'\n  | 'create'\n  | 'delete'\n  | 'forgotPassword'\n  | 'login'\n  | 'read'\n  | 'refresh'\n  | 'update'\n\ntype CreateOrUpdateOperation = Extract<HookOperationType, 'create' | 'update'>\n\nexport type BeforeOperationHook = (args: {\n  args?: any\n  context: RequestContext\n  /**\n   * Hook operation being performed\n   */\n  operation: HookOperationType\n}) => any\n\nexport type BeforeValidateHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  data?: Partial<T>\n  /**\n   * Hook operation being performed\n   */\n  operation: CreateOrUpdateOperation\n  /**\n   * Original document before change\n   *\n   * `undefined` on 'create' operation\n   */\n  originalDoc?: T\n  req?: PayloadRequest\n}) => any\n\nexport type BeforeChangeHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  data: Partial<T>\n  /**\n   * Hook operation being performed\n   */\n  operation: CreateOrUpdateOperation\n  /**\n   * Original document before change\n   *\n   * `undefined` on 'create' operation\n   */\n  originalDoc?: T\n  req: PayloadRequest\n}) => any\n\nexport type AfterChangeHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  doc: T\n  /**\n   * Hook operation being performed\n   */\n  operation: CreateOrUpdateOperation\n  previousDoc: T\n  req: PayloadRequest\n}) => any\n\nexport type BeforeReadHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  doc: T\n  query: { [key: string]: any }\n  req: PayloadRequest\n}) => any\n\nexport type AfterReadHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  doc: T\n  findMany?: boolean\n  query?: { [key: string]: any }\n  req: PayloadRequest\n}) => any\n\nexport type BeforeDeleteHook = (args: {\n  context: RequestContext\n  id: number | string\n  req: PayloadRequest\n}) => any\n\nexport type AfterDeleteHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  doc: T\n  id: number | string\n  req: PayloadRequest\n}) => any\n\nexport type AfterOperationHook<T extends TypeWithID = any> = (\n  arg: AfterOperationArg<T>,\n) => Promise<ReturnType<AfterOperationMap<T>[keyof AfterOperationMap<T>]>>\n\nexport type AfterErrorHook = (\n  err: Error,\n  res: unknown,\n  context: RequestContext,\n) => { response: any; status: number } | void\n\nexport type BeforeLoginHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  req: PayloadRequest\n  user: T\n}) => any\n\nexport type AfterLoginHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  req: PayloadRequest\n  token: string\n  user: T\n}) => any\n\nexport type AfterLogoutHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  req: PayloadRequest\n  res: Response\n}) => any\n\nexport type AfterMeHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  req: PayloadRequest\n  response: unknown\n}) => any\n\nexport type AfterRefreshHook<T extends TypeWithID = any> = (args: {\n  context: RequestContext\n  exp: number\n  req: PayloadRequest\n  res: Response\n  token: string\n}) => any\n\nexport type AfterForgotPasswordHook = (args: { args?: any; context: RequestContext }) => any\n\ntype BeforeDuplicateArgs<T> = {\n  data: T\n  locale?: string\n}\n\nexport type BeforeDuplicate<T = any> = (args: BeforeDuplicateArgs<T>) => Promise<T> | T\n\nexport type CollectionAdminOptions = {\n  /**\n   * Custom admin components\n   */\n  components?: {\n    AfterList?: React.ComponentType<ListProps>[]\n    AfterListTable?: React.ComponentType<ListProps>[]\n    BeforeList?: React.ComponentType<ListProps>[]\n    BeforeListTable?: React.ComponentType<ListProps>[]\n    /**\n     * Components within the edit view\n     */\n    edit?: {\n      /**\n       * Replaces the \"Preview\" button\n       */\n      PreviewButton?: CustomPreviewButtonProps\n      /**\n       * Replaces the \"Publish\" button\n       * + drafts must be enabled\n       */\n      PublishButton?: CustomPublishButtonProps\n      /**\n       * Replaces the \"Save\" button\n       * + drafts must be disabled\n       */\n      SaveButton?: CustomSaveButtonProps\n      /**\n       * Replaces the \"Save Draft\" button\n       * + drafts must be enabled\n       * + autosave must be disabled\n       */\n      SaveDraftButton?: CustomSaveDraftButtonProps\n    }\n    views?: {\n      /**\n       * Set to a React component to replace the entire \"Edit\" view, including all nested routes.\n       * Set to an object to replace or modify individual nested routes, or to add new ones.\n       */\n      Edit?:\n        | {\n            [key: string]: EditView\n            /**\n             * Replace or modify individual nested routes, or add new ones:\n             * + `Default` - `/admin/collections/:collection/:id`\n             * + `API` - `/admin/collections/:collection/:id/api`\n             * + `LivePreview` - `/admin/collections/:collection/:id/preview`\n             * + `References` - `/admin/collections/:collection/:id/references`\n             * + `Relationships` - `/admin/collections/:collection/:id/relationships`\n             * + `Versions` - `/admin/collections/:collection/:id/versions`\n             * + `Version` - `/admin/collections/:collection/:id/versions/:version`\n             * + `:path` - `/admin/collections/:collection/:id/:path`\n             */\n            Default?: EditView\n            Versions?: EditView\n            // TODO: uncomment these as they are built\n            // API?: EditView\n            // LivePreview?: EditView\n            // References?: EditView\n            // Relationships?: EditView\n            // Version: EditView\n          }\n        | EditViewComponent\n      List?: React.ComponentType<ListProps>\n    }\n  }\n  /**\n   * Default columns to show in list view\n   */\n  defaultColumns?: string[]\n  /**\n   * Custom description for collection\n   */\n  description?: EntityDescription\n  disableDuplicate?: boolean\n  enableRichTextLink?: boolean\n  enableRichTextRelationship?: boolean\n  /**\n   * Place collections into a navigational group\n   * */\n  group?: Record<string, string> | string\n  /**\n   * Exclude the collection from the admin nav and routes\n   */\n  hidden?: ((args: { user: User }) => boolean) | boolean\n  /**\n   * Hide the API URL within the Edit view\n   */\n  hideAPIURL?: boolean\n  hooks?: {\n    /**\n     * Function that allows you to modify a document's data before it is duplicated\n     */\n    beforeDuplicate?: BeforeDuplicate\n  }\n  /**\n   * Additional fields to be searched via the full text search\n   */\n  listSearchableFields?: string[]\n  /**\n   * Live preview options\n   */\n  livePreview?: LivePreview\n  pagination?: {\n    defaultLimit?: number\n    limits?: number[]\n  }\n  /**\n   * Function to generate custom preview URL\n   */\n  preview?: GeneratePreviewURL\n  /**\n   * Field to use as title in Edit view and first column in List view\n   */\n  useAsTitle?: string\n}\n\n/** Manage all aspects of a data collection */\nexport type CollectionConfig = {\n  /**\n   * Access control\n   */\n  access?: {\n    admin?: (args?: any) => Promise<boolean> | boolean\n    create?: Access\n    delete?: Access\n    read?: Access\n    readVersions?: Access\n    unlock?: Access\n    update?: Access\n  }\n  /**\n   * Collection admin options\n   */\n  admin?: CollectionAdminOptions\n  /**\n   * Collection login options\n   *\n   * Use `true` to enable with default options\n   */\n  auth?: IncomingAuthType | boolean\n  /** Extension point to add your custom data. */\n  custom?: Record<string, any>\n  /**\n   * Default field to sort by in collection list view\n   */\n  defaultSort?: string\n  /**\n   * Custom rest api endpoints, set false to disable all rest endpoints for this collection.\n   */\n  endpoints?: Omit<Endpoint, 'root'>[] | false\n  fields: Field[]\n  /**\n   * GraphQL configuration\n   */\n  graphQL?:\n    | {\n        pluralName?: string\n        singularName?: string\n      }\n    | false\n  /**\n   * Hooks to modify Payload functionality\n   */\n  hooks?: {\n    afterChange?: AfterChangeHook[]\n    afterDelete?: AfterDeleteHook[]\n    afterError?: AfterErrorHook\n    afterForgotPassword?: AfterForgotPasswordHook[]\n    afterLogin?: AfterLoginHook[]\n    afterLogout?: AfterLogoutHook[]\n    afterMe?: AfterMeHook[]\n    afterOperation?: AfterOperationHook[]\n    afterRead?: AfterReadHook[]\n    afterRefresh?: AfterRefreshHook[]\n    beforeChange?: BeforeChangeHook[]\n    beforeDelete?: BeforeDeleteHook[]\n    beforeLogin?: BeforeLoginHook[]\n    beforeOperation?: BeforeOperationHook[]\n    beforeRead?: BeforeReadHook[]\n    beforeValidate?: BeforeValidateHook[]\n  }\n  /**\n   * Array of database indexes to create, including compound indexes that have multiple fields\n   */\n  indexes?: TypeOfIndex[]\n  /**\n   * Label configuration\n   */\n  labels?: {\n    plural?: Record<string, string> | string\n    singular?: Record<string, string> | string\n  }\n  slug: string\n  /**\n   * Add `createdAt` and `updatedAt` fields\n   *\n   * @default true\n   */\n  timestamps?: boolean\n  /**\n   * Options used in typescript generation\n   */\n  typescript?: {\n    /**\n     * Typescript generation name given to the interface type\n     */\n    interface?: string\n  }\n  /**\n   * Customize the handling of incoming file uploads\n   *\n   * @default false // disable uploads\n   */\n  upload?: IncomingUploadType | boolean\n  /**\n   * Customize the handling of incoming file uploads\n   *\n   * @default false // disable versioning\n   */\n  versions?: IncomingCollectionVersions | boolean\n}\n\nexport interface SanitizedCollectionConfig\n  extends Omit<\n    DeepRequired<CollectionConfig>,\n    'auth' | 'endpoints' | 'fields' | 'upload' | 'versions'\n  > {\n  auth: Auth\n  endpoints: Omit<Endpoint, 'root'>[] | false\n  fields: Field[]\n  upload: Upload\n  versions: SanitizedCollectionVersions\n}\n\nexport type Collection = {\n  config: SanitizedCollectionConfig\n  graphQL?: {\n    JWT: GraphQLObjectType\n    mutationInputType: GraphQLNonNull<any>\n    paginatedType: GraphQLObjectType\n    type: GraphQLObjectType\n    updateMutationInputType: GraphQLNonNull<any>\n    versionType: GraphQLObjectType\n    whereInputType: GraphQLInputObjectType\n  }\n}\n\nexport type BulkOperationResult<TSlug extends keyof GeneratedTypes['collections']> = {\n  docs: GeneratedTypes['collections'][TSlug][]\n  errors: {\n    id: GeneratedTypes['collections'][TSlug]['id']\n    message: string\n  }[]\n}\n\nexport type AuthCollection = {\n  config: SanitizedCollectionConfig\n}\n\nexport type TypeWithID = {\n  id: number | string\n}\n\nexport type TypeWithTimestamps = {\n  [key: string]: unknown\n  createdAt: string\n  id: number | string\n  updatedAt: string\n}\n\ntype IndexDirection =\n  | '2d'\n  | '2dsphere'\n  | 'asc'\n  | 'ascending'\n  | 'desc'\n  | 'descending'\n  | 'geoHaystack'\n  | 'hashed'\n  | 'text'\n  | -1\n  | 1\n\ntype IndexOptions = {\n  '2dsphereIndexVersion'?: number\n  /** Creates the index in the background, yielding whenever possible. */\n  background?: boolean\n  bits?: number\n  bucketSize?: number\n  /** (MongoDB 4.4. or higher) Specifies how many data-bearing members of a replica set, including the primary, must complete the index builds successfully before the primary marks the indexes as ready. This option accepts the same values for the \"w\" field in a write concern plus \"votingMembers\", which indicates all voting data-bearing nodes. */\n  commitQuorum?: number | string\n  default_language?: string\n  /** Allows you to expire data on indexes applied to a data (MongoDB 2.2 or higher) */\n  expireAfterSeconds?: number\n  expires?: number | string\n  /** Specifies that the index should exist on the target collection but should not be used by the query planner when executing operations. (MongoDB 4.4 or higher) */\n  hidden?: boolean\n  language_override?: string\n  /** For geospatial indexes set the high bound for the co-ordinates. */\n  max?: number\n  /** For geospatial indexes set the lower bound for the co-ordinates. */\n  min?: number\n  /** Override the autogenerated index name (useful if the resulting name is larger than 128 bytes) */\n  name?: string\n  /** Creates a sparse index. */\n  sparse?: boolean\n  textIndexVersion?: number\n  /** Creates an unique index. */\n  unique?: boolean\n  /** Specifies the index version number, either 0 or 1. */\n  version?: number\n  weights?: Record<string, number>\n}\n\nexport type TypeOfIndex = {\n  fields: Record<string, IndexDirection>\n  options?: IndexOptions\n}\n"],"names":[],"mappings":"AAAA,qDAAqD"}