@payloadcms/plugin-mcp 4.0.0-internal.a1317b2 → 4.0.0-internal.a2d053c

package/src/mcp/builtin/collections/deleteTool.ts

@@ -1,4 +1,4 @@
-import { deleteDocumentsInputSchema } from 'payload'
+import { deleteDocumentsInputSchema, parseDocumentID } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
@@ -32,7 +32,7 @@ export const deleteDocumentsTool = defineCollectionTool({
   try {
     if (id !== undefined) {
       const result = await payload.delete({
-        id,
+        id: parseDocumentID({ id, collectionSlug: slug, payload }),
         collection: slug,
         depth,
         overrideAccess: authorizedMCP.overrideAccess,
@@ -48,7 +48,7 @@ export const deleteDocumentsTool = defineCollectionTool({
             text: `Document deleted successfully from collection "${slug}"!\nDeleted document:\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
           },
         ],
-        doc: result as Record<string, unknown>,
+        doc: result,
       }
     }
 

package/src/mcp/builtin/collections/duplicateTool.ts

@@ -1,6 +1,7 @@
 import {
   duplicateDocumentInputSchema,
   getCollectionVirtualFieldNames,
+  parseDocumentID,
   stripVirtualFields,
   transformPointDataToPayload,
   validateCollectionData,
@@ -50,7 +51,7 @@ export const duplicateDocumentTool = defineCollectionTool({
     const parsedData = inputData ? transformPointDataToPayload(inputData) : undefined
 
     const result = await payload.duplicate({
-      id,
+      id: parseDocumentID({ id, collectionSlug: slug, payload }),
       collection: slug,
       depth,
       draft,
@@ -73,7 +74,7 @@ export const duplicateDocumentTool = defineCollectionTool({
           text: `Document duplicated successfully in collection "${slug}"!\nDuplicated document:\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
         },
       ],
-      doc: result as Record<string, unknown>,
+      doc: result,
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'

package/src/mcp/builtin/collections/fileInput.ts

@@ -1,7 +1,11 @@
-import type { CollectionSlug, File, FileData, PayloadRequest } from 'payload'
+import type { CollectionSlug, File, PayloadRequest } from 'payload'
 
 import { APIError, z } from 'payload'
-import { getExternalFile, getFileFromUploadInstructions, isURLAllowed } from 'payload/internal'
+import {
+  externalURLInputSchema,
+  getFileFromUploadInstructions,
+  resolveURLUploadInput,
+} from 'payload/internal'
 import { sanitizeFilename } from 'payload/shared'
 
 const mimeTypeSchema = z
@@ -30,11 +34,7 @@ export const fileInputSchema = z
       mimeType: mimeTypeSchema.check(z.describe('The file MIME type, for example image/png.')),
       source: z.literal('base64'),
     }),
-    z.strictObject({
-      name: z.optional(z.string().check(z.minLength(1))).check(z.describe('File name override.')),
-      source: z.literal('externalURL'),
-      url: z.url().check(z.describe('The http or https URL to download.')),
-    }),
+    externalURLInputSchema,
     z.strictObject({
       file: uploadFileSchema.check(z.describe('getUploadInstructions file field post-upload.')),
       source: z.literal('uploadReference'),
@@ -75,6 +75,10 @@ export async function resolveFile({
     }
   }
 
+  if (input.source === 'externalURL') {
+    return resolveURLUploadInput({ slug, input, req })
+  }
+
   const uploadConfig = req.payload.collections[slug]?.config.upload
 
   if (!uploadConfig) {
@@ -82,48 +86,12 @@ export async function resolveFile({
   }
 
   const maxFileSize = req.payload.config.upload.limits?.fileSize
-  let file: File
-
-  if (input.source === 'base64') {
-    const data = decodeBase64({ maxFileSize, value: input.data })
-
-    file = {
-      name: sanitizeFilename(input.name),
-      data,
-      mimetype: input.mimeType,
-      size: data.length,
-    }
-  } else {
-    if (uploadConfig.pasteURL === false) {
-      throw new APIError(`Uploading files from URLs is disabled for collection "${slug}".`, 400)
-    }
-
-    const url = new URL(input.url)
-
-    if (!['http:', 'https:'].includes(url.protocol)) {
-      throw new APIError('File URLs must use http or https.', 400)
-    }
-
-    if (
-      typeof uploadConfig.pasteURL === 'object' &&
-      !isURLAllowed(input.url, uploadConfig.pasteURL.allowList)
-    ) {
-      throw new APIError('The provided file URL is not allowed.', 400)
-    }
-
-    file = await getExternalFile({
-      data: {
-        filename: sanitizeFilename(input.name || getURLFilename(url)),
-        url: input.url,
-      } as FileData,
-      req,
-      uploadConfig: {
-        ...uploadConfig,
-        externalFileHeaderFilter: uploadConfig.externalFileHeaderFilter ?? (() => ({})),
-      },
-    })
-    file.mimetype = file.mimetype?.split(';')[0] || 'application/octet-stream'
-    file.size = file.data.length
+  const data = decodeBase64({ maxFileSize, value: input.data })
+  const file: File = {
+    name: sanitizeFilename(input.name),
+    data,
+    mimetype: input.mimeType,
+    size: data.length,
   }
 
   if (maxFileSize !== undefined && Number.isFinite(maxFileSize) && file.size > maxFileSize) {
@@ -157,13 +125,3 @@ function decodeBase64({ maxFileSize, value }: { maxFileSize?: number; value: str
 
   return data
 }
-
-function getURLFilename(url: URL): string {
-  const pathSegment = url.pathname.split('/').pop() || 'upload'
-
-  try {
-    return decodeURIComponent(pathSegment)
-  } catch {
-    return pathSegment
-  }
-}

package/src/mcp/builtin/collections/findTool.ts

@@ -1,4 +1,4 @@
-import { findDocumentsInputSchema } from 'payload'
+import { findDocumentsInputSchema, parseDocumentID } from 'payload'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
@@ -45,10 +45,10 @@ export const findDocumentsTool = defineCollectionTool({
   )
 
   try {
-    if (id) {
+    if (id !== undefined) {
       try {
         const doc = await payload.findByID({
-          id,
+          id: parseDocumentID({ id, collectionSlug: slug, payload }),
           collection: slug,
           depth,
           overrideAccess: authorizedMCP.overrideAccess,
@@ -69,7 +69,7 @@ export const findDocumentsTool = defineCollectionTool({
               text: `Document from collection "${slug}":\n${JSON.stringify(doc)}`,
             },
           ],
-          doc: doc as Record<string, unknown>,
+          doc,
         }
       } catch {
         logger.warn(`Document not found with ID: ${id} in collection: ${slug}`)

package/src/mcp/builtin/collections/getCollectionSchemaTool.ts

@@ -1,4 +1,5 @@
 import { getAccessResults, getCollectionInputSchema, getCollectionSchemaInputSchema } from 'payload'
+import { getLLMInstructions } from 'payload/internal'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
@@ -16,7 +17,8 @@ export const getCollectionSchemaTool = defineCollectionTool({
     readOnlyHint: true,
     title: 'Get Collection Schema',
   },
-  description: 'Get the input schema for creating or updating documents in a collection.',
+  description:
+    'Get the input schema and LLM instructions before creating or updating documents in a collection.',
   input: getCollectionSchemaInputSchema,
 }).handler(async ({ slug, authorizedMCP, req }) => {
   const permissions = authorizedMCP.overrideAccess
@@ -64,17 +66,26 @@ export const getCollectionSchemaTool = defineCollectionTool({
       }
     : { enabled: false }
 
+  const instructions = await getLLMInstructions({
+    slug,
+    type: 'collection',
+    overrideAccess: authorizedMCP.overrideAccess,
+    req,
+  })
+
   return {
     content: [
       {
         type: 'text',
         text: `Schema for collection "${slug}":\n\`\`\`json\n${JSON.stringify(inputSchema)}\n\`\`\`\nUpload configuration:\n\`\`\`json\n${JSON.stringify(upload)}\n\`\`\``,
       },
+      ...(instructions ? [{ type: 'text' as const, text: instructions }] : []),
     ],
     structuredContent: {
       slug,
       schema: inputSchema,
       upload,
+      ...(instructions ? { instructions } : {}),
     },
   }
 })

package/src/mcp/builtin/collections/restoreVersionTool.ts

@@ -47,7 +47,7 @@ export const restoreVersionTool = defineCollectionTool({
           text: `Version "${id}" restored successfully in collection "${slug}"!\nRestored document:\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
         },
       ],
-      doc: result as Record<string, unknown>,
+      doc: result,
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'

package/src/mcp/builtin/collections/updateTool.ts

@@ -3,6 +3,7 @@ import type { Where } from 'payload'
 import {
   getCollectionInputSchema,
   getCollectionVirtualFieldNames,
+  parseDocumentID,
   stripVirtualFields,
   transformPointDataToPayload,
   updateDocumentInputSchema,
@@ -46,6 +47,7 @@ export const updateDocumentTool = defineCollectionTool({
     overrideLock,
     populate,
     publishAllLocales,
+    returning,
     select,
     sort,
     trash,
@@ -74,7 +76,7 @@ export const updateDocumentTool = defineCollectionTool({
 
     if (id !== undefined) {
       const result = await payload.update({
-        id,
+        id: parseDocumentID({ id, collectionSlug: slug, payload }),
         collection: slug,
         data: parsedData,
         depth,
@@ -86,20 +88,22 @@ export const updateDocumentTool = defineCollectionTool({
         populate,
         publishAllLocales,
         req,
-        select,
+        select: returning ? select : { id: true },
         trash,
         unpublishAllLocales,
         ...(file ? { file } : {}),
       })
 
+      const responseResult = returning ? result : { id: result.id }
+
       return {
         content: [
           {
             type: 'text',
-            text: `Document updated successfully in collection "${slug}"!\nUpdated document:\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+            text: `Document updated successfully in collection "${slug}"!\nResult:\n\`\`\`json\n${JSON.stringify(responseResult)}\n\`\`\``,
           },
         ],
-        doc: result as Record<string, unknown>,
+        doc: responseResult,
       }
     }
 
@@ -116,7 +120,7 @@ export const updateDocumentTool = defineCollectionTool({
       populate,
       publishAllLocales,
       req,
-      select,
+      select: returning ? select : { id: true },
       sort,
       trash,
       unpublishAllLocales,
@@ -124,7 +128,7 @@ export const updateDocumentTool = defineCollectionTool({
       ...(file ? { file } : {}),
     })
 
-    const docs = result.docs || []
+    const docs = returning ? result.docs : result.docs.map(({ id }) => ({ id }))
     const errors = result.errors || []
 
     let responseText = `Multiple documents updated in collection "${slug}"!\nUpdated: ${docs.length} documents\nErrors: ${errors.length}\n---`

package/src/mcp/builtin/collections/uploadInstructionsTool.ts

@@ -9,7 +9,7 @@ export const getUploadInstructionsTool = defineCollectionTool({
     defaultAccess(args) &&
     Boolean(
       args.permissions?.collections?.[args.slug]?.create ||
-        args.permissions?.collections?.[args.slug]?.update,
+      args.permissions?.collections?.[args.slug]?.update,
     ),
   annotations: {
     destructiveHint: false,

package/src/mcp/builtin/globals/findTool.ts

@@ -54,7 +54,7 @@ export const findGlobalTool = defineGlobalTool({
           text: `Global "${slug}":\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
         },
       ],
-      doc: result as Record<string, unknown>,
+      doc: result,
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error'

package/src/mcp/builtin/globals/getGlobalSchemaTool.ts

@@ -1,4 +1,5 @@
 import { getAccessResults, getGlobalInputSchema, getGlobalSchemaInputSchema } from 'payload'
+import { getLLMInstructions } from 'payload/internal'
 
 import { defaultAccess } from '../../../defaultAccess.js'
 import { defineGlobalTool } from '../../../defineTool.js'
@@ -16,7 +17,7 @@ export const getGlobalSchemaTool = defineGlobalTool({
     readOnlyHint: true,
     title: 'Get Global Schema',
   },
-  description: 'Get the input schema for updating a global.',
+  description: 'Get the input schema and LLM instructions before updating a global.',
   input: getGlobalSchemaInputSchema,
 }).handler(async ({ slug, authorizedMCP, req }) => {
   const permissions = authorizedMCP.overrideAccess
@@ -48,16 +49,25 @@ export const getGlobalSchemaTool = defineGlobalTool({
     }
   }
 
+  const instructions = await getLLMInstructions({
+    slug,
+    type: 'global',
+    overrideAccess: authorizedMCP.overrideAccess,
+    req,
+  })
+
   return {
     content: [
       {
         type: 'text',
         text: `Schema for global "${slug}":\n\`\`\`json\n${JSON.stringify(inputSchema)}\n\`\`\``,
       },
+      ...(instructions ? [{ type: 'text' as const, text: instructions }] : []),
     ],
     structuredContent: {
       slug,
       schema: inputSchema,
+      ...(instructions ? { instructions } : {}),
     },
   }
 })

package/src/mcp/builtin/globals/updateTool.ts

@@ -82,7 +82,7 @@ export const updateGlobalTool = defineGlobalTool({
           text: `Global "${slug}" updated successfully!\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
         },
       ],
-      doc: result as Record<string, unknown>,
+      doc: result,
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Unknown error'

package/src/mcp/sanitizeMCPConfig.ts

@@ -103,6 +103,7 @@ export const sanitizeMCPConfig = ({
     hooks: pluginConfig.hooks,
     items,
     mcp: pluginConfig.mcp,
+    oauth: pluginConfig.oauth === false ? undefined : (pluginConfig.oauth ?? { type: 'builtin' }),
     overrideGetAuthorizedMCP: pluginConfig.overrideGetAuthorizedMCP,
   }
 }

package/src/stdio.ts

@@ -3,7 +3,7 @@ import type { Config, Plugin, SanitizedConfig } from 'payload'
 /* eslint-disable no-console */
 import { serveStdio } from '@modelcontextprotocol/server/stdio'
 import { fileURLToPath, pathToFileURL } from 'node:url'
-import { createLocalReq, getPayload } from 'payload'
+import { createPayloadRequest, getPayload } from 'payload'
 import { findConfig, loadEnv } from 'payload/node'
 
 import type { SanitizedMCPPluginConfig } from './types.js'
@@ -91,7 +91,7 @@ export const runMcpStdio = async (): Promise<void> => {
     headers.set('Authorization', process.env.PAYLOAD_MCP_AUTHORIZATION)
   }
 
-  const req = await createLocalReq({ req: { headers } }, payload)
+  const req = await createPayloadRequest({ payload, req: { headers } })
   req.payloadAPI = 'MCP' as const
   const authorizedMCP = await getAuthorizedMCP({ overrideAccess, req })
 

package/src/types.ts

@@ -1,8 +1,9 @@
 import type {
   CallToolResult,
   ContentBlock,
+  Implementation,
   JsonSchemaType,
-  McpServer,
+  McpServerOptions,
   ResourceTemplate,
   ServerContext,
   StandardSchemaWithJSON,
@@ -279,9 +280,24 @@ export type MCPPluginConfig = {
     afterToolCall?: MCPAfterToolCallHook[]
   }
   mcp?: {
+    /**
+     * Largest HTTP request body, in bytes, that the MCP endpoint accepts. Larger requests
+     * are answered with `413`. Base64 file uploads count toward this limit.
+     *
+     * @default 4194304 (4 MiB, the MCP SDK default)
+     */
+    maxRequestBodySize?: number
     serverOptions?: MCPServerOptions
     verboseLogs?: boolean
   }
+  /**
+   * How MCP clients sign in. MCP requests without an authenticated user get a `401` that points
+   * to the protected resource metadata (RFC 9728). Set to `false` to only accept API keys and
+   * anonymous requests.
+   *
+   * @default { type: 'builtin' }
+   */
+  oauth?: false | MCPOAuthConfig
   /**
    * Replace the default MCP authorization resolver.
    *
@@ -299,13 +315,88 @@ export type MCPPluginConfig = {
   tools?: MCPTopLevelToolsMap
 }
 
+export type MCPOAuthConfig = MCPBuiltinOAuthConfig | MCPExternalOAuthConfig
+
+/**
+ * This Payload app is the authorization server. Users sign in to the admin panel and allow the
+ * MCP client, which then gets an access token for them.
+ */
+export type MCPBuiltinOAuthConfig = {
+  /**
+   * Creates the tokens the MCP client gets when the user clicks Allow. `req` is the user's own
+   * browser request, so `req.user` is the user who allowed it. Pass `authenticate` too if
+   * Payload's auth strategies don't accept the access token.
+   *
+   * @default a Payload login token for that user that only works for MCP, with a refresh token when
+   * the collection uses sessions
+   */
+  issueToken?: (args: { req: PayloadRequest }) => MaybePromise<MCPOAuthTokens>
+  /**
+   * Trades a refresh token from `issueToken`, or from an earlier refresh, for new tokens. Return
+   * `null` when it's no longer valid, and the client sends the user through sign-in again. `req`
+   * is the MCP client's request, without a user. Only used together with `issueToken`.
+   *
+   * OAuth requires noticing copied refresh tokens: return a new refresh token every time, and
+   * revoke the tokens when an already used refresh token comes back.
+   */
+  refreshToken?: (args: {
+    refreshToken: string
+    req: PayloadRequest
+  }) => MaybePromise<MCPOAuthTokens | null>
+  type: 'builtin'
+} & MCPOAuthSharedConfig
+
+export type MCPOAuthTokens = {
+  accessToken: string
+  /** Seconds until the access token expires. */
+  expiresIn?: number
+  /** Lets the client get new tokens without the user, through `refreshToken`. */
+  refreshToken?: string
+}
+
+/** Another service, e.g. your identity provider, is the authorization server. */
+export type MCPExternalOAuthConfig = {
+  /**
+   * The authorization servers that issue access tokens for MCP clients. Clients require each one
+   * to exactly match the `issuer` in that server's metadata, so pass a function when the exact
+   * value is only known at runtime, e.g. from the server's OpenID configuration or per host.
+   */
+  authorizationServers: ((args: { req: PayloadRequest }) => MaybePromise<string[]>) | string[]
+  /**
+   * Scopes MCP clients should request, e.g. `['openid', 'email', 'profile']`. Without them,
+   * clients request none, which some authorization servers reject or answer with a token that
+   * doesn't identify the user.
+   */
+  scopes?: string[]
+  type: 'external'
+} & MCPOAuthSharedConfig
+
+type MCPOAuthSharedConfig = {
+  /**
+   * Called on MCP requests with a bearer token that Payload's auth strategies didn't accept.
+   * Return the Payload user, including its `collection`, or `null` to answer with the OAuth challenge.
+   */
+  authenticate?: (args: {
+    req: PayloadRequest
+    token: string
+  }) => MaybePromise<PayloadRequest['user']>
+  /**
+   * The URL clients call to reach the MCP endpoint.
+   *
+   * @default the absolute URL of `/api/mcp`, based on `serverURL` or the request URL
+   */
+  resource?: string
+}
+
 export type SanitizedMCPPluginConfig = {
   items: MCPItem[]
+  /** `undefined` when OAuth is turned off. */
+  oauth?: MCPOAuthConfig
 } & Pick<MCPPluginConfig, 'disabled' | 'hooks' | 'mcp' | 'overrideGetAuthorizedMCP'>
 
 export type MCPServerOptions = {
-  options?: ConstructorParameters<typeof McpServer>[1]
-  serverInfo?: Partial<ConstructorParameters<typeof McpServer>[0]>
+  options?: McpServerOptions
+  serverInfo?: Partial<Implementation>
 }
 
 /**

package/src/utils/seal.ts

@@ -0,0 +1,46 @@
+import type { PayloadRequest } from 'payload'
+
+/**
+ * Encrypts data for the client to hold, so it doesn't need to be stored. `type` keeps one kind
+ * from being used as another, e.g. a client ID as an authorization code.
+ */
+export const seal = ({
+  type,
+  data,
+  expiresIn,
+  req,
+}: {
+  data: object
+  /** Seconds */
+  expiresIn?: number
+  req: PayloadRequest
+  type: string
+}): string =>
+  req.payload.encrypt(
+    JSON.stringify({ ...data, type, exp: expiresIn && Date.now() + expiresIn * 1000 }),
+  )
+
+export const unseal = <T>({
+  type,
+  req,
+  value,
+}: {
+  req: PayloadRequest
+  type: string
+  value: null | string
+}): T | undefined => {
+  // Only the v1 format is authenticated. Older formats decrypt anything without an error.
+  if (!value?.startsWith('v1:')) {
+    return undefined
+  }
+
+  try {
+    // Previous secrets can be public, like a default secret from source code, so only client IDs
+    // accept them. Client IDs grant nothing, and this keeps clients registered when the secret changes.
+    const secret = type === 'client' ? undefined : req.payload.config.secret
+    const data = JSON.parse(req.payload.decrypt(value, { secret }))
+    return data.type === type && (!data.exp || data.exp > Date.now()) ? data : undefined
+  } catch {
+    return undefined
+  }
+}

package/src/utils/toStandardSchema.ts

@@ -5,5 +5,5 @@ import type { ToolInputSchema } from '../types.js'
 /** Normalize a tool/prompt input to a Standard Schema. Raw JSON Schema gets wrapped; Standard Schema instances pass through. */
 export const toStandardSchema = (schema: ToolInputSchema): StandardSchemaWithJSON =>
   typeof schema === 'object' && schema !== null && '~standard' in schema
-    ? (schema as StandardSchemaWithJSON)
+    ? schema
     : fromJsonSchema(schema)

package/dist/mcp/builtin/collections/fileInput.spec.js

@@ -1,86 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { fileInputSchema, resolveFile } from './fileInput.js';
-describe('MCP file input', ()=>{
-    it('should reject malformed MIME types', ()=>{
-        const result = fileInputSchema.safeParse({
-            data: 'aGVsbG8=',
-            mimeType: 'text/plain\r\nx-test: value',
-            name: 'hello.txt',
-            source: 'base64'
-        });
-        expect(result.success).toBe(false);
-    });
-    it('should accept a prepared upload', ()=>{
-        const result = fileInputSchema.safeParse({
-            file: {
-                filename: 'image.png',
-                mimeType: 'image/png',
-                size: 123,
-                uploadReference: {
-                    uploadId: 'upload-id'
-                }
-            },
-            source: 'uploadReference'
-        });
-        expect(result.success).toBe(true);
-    });
-    it('should reject oversized base64 files', async ()=>{
-        const req = createRequest({
-            maxFileSize: 4
-        });
-        await expect(resolveFile({
-            slug: 'media',
-            input: {
-                data: Buffer.from('hello').toString('base64'),
-                mimeType: 'text/plain',
-                name: 'hello.txt',
-                source: 'base64'
-            },
-            req
-        })).rejects.toThrow('File exceeds the 4 byte upload limit.');
-    });
-    it('should reject URLs outside the collection allowlist', async ()=>{
-        const req = createRequest({
-            allowList: [
-                {
-                    hostname: 'assets.example.com',
-                    protocol: 'https'
-                }
-            ]
-        });
-        await expect(resolveFile({
-            slug: 'media',
-            input: {
-                source: 'externalURL',
-                url: 'https://example.com/image.png'
-            },
-            req
-        })).rejects.toThrow('The provided file URL is not allowed.');
-    });
-});
-function createRequest({ allowList, maxFileSize }) {
-    return {
-        payload: {
-            collections: {
-                media: {
-                    config: {
-                        upload: allowList ? {
-                            pasteURL: {
-                                allowList
-                            }
-                        } : {}
-                    }
-                }
-            },
-            config: {
-                upload: {
-                    limits: {
-                        fileSize: maxFileSize
-                    }
-                }
-            }
-        }
-    };
-}
-
-//# sourceMappingURL=fileInput.spec.js.map