@jpmorganchase/mosaic-types 0.1.0-beta.6 → 0.1.0-beta.61

package/dist/Content.d.ts

@@ -0,0 +1,11 @@
+/**
+ *  [[`ContentProps`]] specifies the page source/content
+ */
+export interface ContentProps {
+    /** Page source, which will be page type specific */
+    source?: Record<string, unknown>;
+    /** Page type */
+    type?: string;
+    /** Raw page content, includes markdown and frontmatter */
+    raw?: string;
+}

package/dist/IFileAccess.d.ts

@@ -1,13 +1,8 @@
-/// <reference types="node" />
-import type { DirectoryJSON, IRealpathOptions, IMkdirOptions, IReaddirOptions, TData, TMode } from 'memfs/lib/volume';
-import type { TDataOut } from 'memfs/lib/encoding';
-import type Dirent from 'memfs/lib/Dirent';
-import type Stats from 'memfs/lib/Stats';
-import type { TStatNumber } from 'memfs/lib/Stats';
-import type { IStatOptions } from 'memfs/lib/volume';
-import type { PathLike, symlink } from 'fs';
-import type { Page } from './Page';
+/// <reference types="node" resolution-mode="require"/>
 import type { Options, Pattern, Entry } from 'fast-glob';
+import type { DirectoryJSON, IRealpathOptions, IMkdirOptions, IReaddirOptions, IStatOptions, TData, TMode, TDataOut, Dirent, Stats, TStatNumber } from 'memfs';
+import type { PathLike, symlink } from 'fs';
+import type { Page } from './Page.js';
 /**
  * This is the core underlying filesystem, which directly interfaces with a memfs Volume to mutate the filesystem
  */

package/dist/Mode.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Mosaic mode dictates how content is loaded
+ *
+ * `active`
+ * In this mode, content is pulled from configured data sources and updates in real-time.
+ * After content is updated, Mosaic plugins create an enhanced, in-memory file object, representing the content
+ *
+ * `snapshot-file`
+ * In this mode, previously created snapshot files are loaded from a local directory.
+ *
+ * `snapshot-s3`
+ * In this mode, previously created snapshot files are loaded from an S3 bucket.
+ *
+ * (A snapshot is an immutable/persisted copy of `active` content, created separately)
+ */
+export declare type MosaicMode = 'active' | 'snapshot-file' | 'snapshot-s3';

package/dist/Page.d.ts

@@ -1,7 +1,7 @@
 /**
  * `Page` is a type, which at a minimum has a `fullPath`, but can also contain metadata and `content`
  */
-export declare type Page<AdditionalProps = {}> = {
+export declare type Page = {
     fullPath: string;
     title?: string;
     /**
@@ -17,4 +17,4 @@ export declare type Page<AdditionalProps = {}> = {
     lastModified?: Date;
     type?: string;
     content?: string;
-} & Record<string, unknown> & AdditionalProps;
+};

package/dist/Plugin.d.ts

@@ -1,16 +1,40 @@
-import type { Page } from './Page';
-import type { MutableData } from './MutableData';
-import type { PluginModuleDefinition } from './PluginModuleDefinition';
-import type { ImmutableData } from './MutableData';
-import type { IUnionVolume, IVolumeImmutable, IVolumeMutable, IVolumePartiallyMutable } from './Volume';
-import type { Serialiser } from './Serialiser';
-export declare type LoadedPlugin = Partial<Plugin> & PluginModuleDefinition;
+import type { IUnionVolume, IVolumeImmutable, IVolumeMutable, IVolumePartiallyMutable } from './Volume.js';
+import type { PluginModuleDefinition } from './index.js';
+import type { Serialiser } from './Serialiser.js';
+import type { Page } from './Page.js';
+import type { MutableData, ImmutableData } from './MutableData.js';
+export declare type LoadedPlugin = Partial<Plugin<Page>> & PluginModuleDefinition;
+export declare type LifecycleMethod = keyof Plugin<Page>;
+export declare type PluginErrorDescriptor = {
+    /**
+     * The plugin lifecycle method running when the error occurred
+     */
+    lifecycleMethod: string;
+    /**
+     * The path to the loaded plugin module
+     */
+    pluginModulePath: string;
+    /**
+     * The name of the plugin
+     */
+    pluginName: string;
+    /**
+     * The name of the error
+     */
+    name: string;
+    /**
+     * The path of the file that triggered the plugin error
+     */
+    fullPath?: string;
+};
+export declare type PluginErrors = Array<PluginErrorDescriptor>;
+export declare type TrackPluginErrorCallback = (errors: Array<PluginErrorDescriptor>, lifecycleMethod: string) => void;
 /**
  * Plugins are lifecycle-based hooks that are called on every source at different stages.
  * Consumers will never need to invoke a lifecycle method; but for technical clarity - when a lifecycle method is called,
  * it will trigger `pluginRunner` which executes it on every source automatically.
  */
-export declare type Plugin<ConfigData = {}, PluginOptions = {}, GlobalConfigData = ConfigData> = {
+export declare type Plugin<TPage extends Page = Page, TOptions = Record<string, unknown>, ConfigData = Record<string, unknown>, GlobalConfigData = ConfigData> = {
     /**
      * Plugin lifecycle method that triggers inside child processes.
      * The first lifecycle hook to trigger after receiving pages from a source. The pages can safely be mutated and will be reflected in the final
@@ -18,30 +42,34 @@ export declare type Plugin<ConfigData = {}, PluginOptions = {}, GlobalConfigData
      * @param pages Array of pages from the source
      * @param param.serialiser A matching `Serialiser` for serialising/deserialising pages when reading/writing to the filesystem
      * @param param.config A mutable object for sharing data with other lifecycle phases of all plugins for this source (including in the main thread) in this plugin
+     * @param param.namespace The namespace of the source running the plugin
      * @param options The options passed in when declaring the plugin
      * @returns {Promise<Page[]>} Must re-return an array of `Page` objects, modified or not
      */
-    $afterSource?(pages: Page[], {}: {
-        serialiser: Serialiser;
+    $afterSource?: (pages: TPage[], helpers: {
+        serialiser: Serialiser<TPage>;
         config: MutableData<ConfigData>;
         pageExtensions: string[];
         ignorePages: string[];
-    }, options?: Pick<PluginModuleDefinition, 'options'> & PluginOptions): Promise<Page[]>;
+        namespace: string;
+    }, options?: TOptions) => Promise<Array<TPage>>;
     /**
      * Plugin lifecycle method that triggers inside child processes.
      * Calls after a filesystem has been built up from the source pages.
      * @param mutableFilesystem Mutable virtual filesystem instance with all of this source's pages inside (and symlinks applied)
      * @param param.serialiser A matching `Serialiser` for serialising/deserialising pages when reading/writing to the filesystem
      * @param param.config A mutable object for sharing data with other lifecycle phases of all plugins for this source (including in the main thread) in this plugin
+     * @param param.namespace The namespace of the source running the plugin
      * @param options The options passed in when declaring the plugin
      * @returns {void} No return expected
      */
-    $beforeSend?(mutableFilesystem: IVolumePartiallyMutable, {}: {
-        serialiser: Serialiser;
+    $beforeSend?: (mutableFilesystem: IVolumePartiallyMutable, helpers: {
+        serialiser: Serialiser<TPage>;
         pageExtensions: string[];
         ignorePages: string[];
         config: MutableData<ConfigData>;
-    }, options?: Pick<PluginModuleDefinition, 'options'> & PluginOptions): Promise<void>;
+        namespace: string;
+    }, options?: TOptions) => Promise<void>;
     /**
      * Plugin lifecycle method that triggers inside the main process.
      * Calls after the filesystem and symlinks have been reconstructed due to a change to the current source. This happens in the main thread.
@@ -56,18 +84,20 @@ export declare type Plugin<ConfigData = {}, PluginOptions = {}, GlobalConfigData
      * @param param.globalConfig An immutable object for reading data from other lifecycle phases of all plugins. Shared across all sources.
      * @param param.sharedFilesystem Mutable filesystem instance independent of any sources. Useful for global pages, like sitemaps
      * @param param.globalFilesystem Immutable union filesystem instance with all source's pages (and symlinks applied)
+     * @param param.namespace The namespace of the source running the plugin
      * @param options The options passed in when declaring the plugin
      * @returns {void} No return expected
      */
-    afterUpdate?(mutableFilesystem: IVolumePartiallyMutable, {}: {
-        serialiser: Serialiser;
+    afterUpdate?: (mutableFilesystem: IVolumePartiallyMutable, helpers: {
+        serialiser: Serialiser<TPage>;
         config: ImmutableData<ConfigData>;
         globalFilesystem: IUnionVolume;
         sharedFilesystem: IVolumeMutable;
         globalConfig: ImmutableData<GlobalConfigData>;
         pageExtensions: string[];
         ignorePages: string[];
-    }, options?: Pick<PluginModuleDefinition, 'options'> & PluginOptions): Promise<void>;
+        namespace: string;
+    }, options?: TOptions) => Promise<void>;
     /**
      * Plugin lifecycle method that triggers inside the main process everytime ANY source emits new pages.
      * This method should return a boolean that will indicate if this source should clear page caches.
@@ -77,15 +107,64 @@ export declare type Plugin<ConfigData = {}, PluginOptions = {}, GlobalConfigData
      * @param param.config An immutable object for reading data from other lifecycle phases of all plugins for this source in the child process for this plugin
      * @param param.serialiser A matching `Serialiser` for serialising/deserialising pages when reading/writing to the filesystem
      * @param param.globalFilesystem Immutable union filesystem instance with all source's pages (and symlinks applied)
+     * @param param.namespace The namespace of the source running the plugin
+     * @param options The options passed in when declaring the plugin
+     * @returns {Promise<boolean>} A boolean indicating whether to clear the cache for this source
+     */
+    shouldClearCache?: (updatedSourceFilesystem: IVolumeImmutable, helpers: {
+        serialiser: Serialiser<TPage>;
+        config: ImmutableData<ConfigData>;
+        globalFilesystem: IUnionVolume;
+        pageExtensions: string[];
+        ignorePages: string[];
+        namespace: string;
+    }, options?: TOptions) => Promise<boolean>;
+    /**
+     * Plugin lifecycle method that triggers inside the main process everytime ANY source emits new pages.
+     * This method should return a boolean that will indicate if this source should force other namespace sources to re-run afterUpdate.
+     * Returning `undefined`, false or no value, will result in no update being triggered for namespace sources
+     * @param updatedSourceFilesystem Immutable filesystem for the source that changed
+     * @param param.config An immutable object for reading data from other lifecycle phases of all plugins for this source in the child process for this plugin
+     * @param param.serialiser A matching `Serialiser` for serialising/deserialising pages when reading/writing to the filesystem
+     * @param param.globalFilesystem Immutable union filesystem instance with all source's pages (and symlinks applied)
+     * @param param.namespace The namespace of the source running the plugin
      * @param options The options passed in when declaring the plugin
      * @returns {Promise<boolean>} A boolean indicating whether to clear the cache for this source
      */
-    shouldClearCache?(updatedSourceFilesystem: IVolumeImmutable, {}: {
-        serialiser: Serialiser;
+    shouldUpdateNamespaceSources?: (updatedSourceFilesystem: IVolumeImmutable, helpers: {
+        serialiser: Serialiser<TPage>;
         config: ImmutableData<ConfigData>;
         globalFilesystem: IUnionVolume;
         pageExtensions: string[];
         ignorePages: string[];
-    }, options?: Pick<PluginModuleDefinition, 'options'> & PluginOptions): Promise<boolean>;
+        namespace: string;
+    }, options?: TOptions) => Promise<boolean>;
+    /**
+     * Plugin lifecycle method that triggers inside the main process **ONLY** if the `shouldUpdateNamespaceSources` method returns true.
+     * Calls after the filesystem and symlinks have been reconstructed due to a change to the current source. This happens in the main thread.
+     * Pages will NOT be cached when read at this stage, to allow for reading content and writing a new copy of it without the cached version taking effect.
+     * This method is safe to use with lazy loading, as the filesystem should return the full page when read.
+     * NOTE: Plugin methods that trigger inside the parent process should be async and highly optimised to avoid holding up the main thread.
+     * You should also be mindful of race conditions when reading / writing to the global filesystem from this method - as other plugins may
+     * also have a read copy of the same file and it could end up out of sync.
+     * @param mutableFilesystem Mutable filesystem instance with all of this source's pages inside (and symlinks re-applied)
+     * @param param.serialiser A matching `Serialiser` for serialising/deserialising pages when reading/writing to the filesystem
+     * @param param.config An immutable object for reading data from other lifecycle phases of all plugins for this source in the child process for this plugin. Shared only with this source.
+     * @param param.globalConfig An immutable object for reading data from other lifecycle phases of all plugins. Shared across all sources.
+     * @param param.sharedFilesystem Mutable filesystem instance independent of any sources. Useful for global pages, like sitemaps
+     * @param param.globalFilesystem Immutable union filesystem instance with all source's pages (and symlinks applied)
+     * @param param.namespace The namespace of the source running the plugin
+     * @param options The options passed in when declaring the plugin
+     * @returns {void} No return expected
+     */
+    afterNamespaceSourceUpdate?: (mutableFilesystem: IVolumePartiallyMutable, helpers: {
+        serialiser: Serialiser<TPage>;
+        config: ImmutableData<ConfigData>;
+        globalFilesystem: IUnionVolume;
+        sharedFilesystem: IVolumeMutable;
+        globalConfig: ImmutableData<GlobalConfigData>;
+        pageExtensions: string[];
+        ignorePages: string[];
+        namespace: string;
+    }, options?: TOptions) => Promise<void>;
 };
-export declare type LifecycleMethod = keyof Plugin;

package/dist/Serialiser.d.ts

@@ -1,26 +1,26 @@
-import type { TDataOut } from 'memfs/lib/encoding';
-import type { Page } from './Page';
-import type { SerialiserModuleDefinition } from './SerialiserModuleDefinition';
+import type { TDataOut } from 'memfs';
+import type { SerialiserModuleDefinition } from './index.js';
+import type { Page } from './Page.js';
 /**
- * Serialisers are a form of plugin that tells PullDocs how to turn a file from/to a storable form for the filesystem
+ * Serialisers are a form of plugin that tells Mosaic how to turn a file from/to a storable form for the filesystem
  * or a `Page` object.
  * For technical clarity - when a parser method is called, it will trigger `parserRunner` which checks the `fullPath` against
- * the `test` option that was passed in the PullDocs config file, to find a suitable parser.
+ * the `test` option that was passed in the Mosaic config file, to find a suitable parser.
  */
-export declare type Serialiser = {
+export declare type Serialiser<TPage extends Page = Page> = {
     /**
      * Method to turn a raw page (e.g. an MDX file) into a `Page` object
      * @param fullPath Route on virtual disk (should be full fullPath, not an alias)
      * @param page Page in string or buffer form (i.e. an MDX page with frontmatter or a JSON file as a string)
      * @returns Page object in the `Page` format
      */
-    deserialise: (fullPath: string, page: TDataOut) => Promise<Page>;
+    deserialise: (fullPath: string, page: TDataOut) => Promise<TPage>;
     /**
      * Method to load a raw page from disk (e.g. an MDX file) and return into a `Page` object
      * @param fullPath Route on virtual disk (should be full fullPath, not an alias)
      * @param page Page in `Page` form
      * @returns Page content
      */
-    serialise: (fullPath: string, page: Page) => Promise<TDataOut>;
+    serialise: (fullPath: string, page: TPage) => Promise<TDataOut>;
 };
 export declare type LoadedSerialiser = Serialiser & SerialiserModuleDefinition;

package/dist/Session.d.ts

@@ -0,0 +1,22 @@
+export declare type JWT = {
+    exp: number;
+    UserID?: string;
+    JPMCIdentifier?: string;
+    UID?: string;
+    EmployeeCorporateID?: string;
+    CostCenter?: string;
+    Country?: string;
+    CountryCode?: string;
+    Department?: string;
+    DisplayName?: string;
+    Email?: string;
+    EmployeeType?: string;
+    FirstName?: string;
+    LastName?: string;
+    LOB?: string;
+    LocationCode?: string;
+};
+export declare type Session<TUserProfile> = {
+    isLoggedIn: boolean;
+    user?: TUserProfile;
+};

package/dist/Source.d.ts

@@ -1,9 +1,24 @@
 import type { Observable } from 'rxjs';
-import type { Serialiser } from './Serialiser';
-import type { Page } from './Page';
-export declare type Source<Options = {}> = {
-    create(options: Options, { serialiser, pageExtensions }: {
-        pageExtensions: string[];
-        serialiser: Serialiser;
-    }): Observable<Page[]>;
+import type { Serialiser } from './Serialiser.js';
+import type { Page } from './Page.js';
+import { SourceSchedule } from './index.js';
+/**
+ * Provided by Mosaic to a Source
+ */
+export declare type SourceConfig = {
+    /**
+     * The allowed page extensions Mosaic has been configured to use
+     */
+    pageExtensions: string[];
+    /**
+     * The page serialiser compatible with the pageExtensions
+     */
+    serialiser: Serialiser;
+    /**
+     * Scheduling configuration for the source
+     */
+    schedule: SourceSchedule;
+};
+export declare type Source<TOptions = Record<string, unknown>, TPage extends Page = Page> = {
+    create(options: TOptions, helpers: SourceConfig): Observable<TPage[]>;
 };

package/dist/SourceWorkflow.d.ts

@@ -0,0 +1,13 @@
+export declare type SourceWorkflowAction<TSourceOptions, TOptions> = (sendWorkflowProgressMessage: SendSourceWorkflowMessage, sourceOptions: TSourceOptions, workflowOptions: TOptions, ...args: any[]) => Promise<unknown>;
+export declare type SourceWorkflow<TSourceOptions = unknown, TOptions = unknown> = {
+    name: string;
+    options?: TOptions;
+    action: SourceWorkflowAction<TSourceOptions, TOptions>;
+};
+export declare type SourceWorkflowMessageStatus = 'SUCCESS' | 'ERROR' | 'IN_PROGRESS' | 'COMPLETE';
+export declare type SendSourceWorkflowMessage = (message: any, status: SourceWorkflowMessageStatus) => void;
+export declare type SourceWorkflowMessageEvent = {
+    status: SourceWorkflowMessageStatus;
+    message: any;
+    channel?: string;
+};

package/dist/Volume.d.ts

@@ -1,10 +1,5 @@
-/// <reference types="node" />
-import type { DirectoryJSON, IRealpathOptions, IMkdirOptions, IReaddirOptions, TData, TMode } from 'memfs/lib/volume';
-import type { TDataOut } from 'memfs/lib/encoding';
-import type Dirent from 'memfs/lib/Dirent';
-import type Stats from 'memfs/lib/Stats';
-import type { TStatNumber } from 'memfs/lib/Stats';
-import type { IStatOptions } from 'memfs/lib/volume';
+/// <reference types="node" resolution-mode="require"/>
+import type { DirectoryJSON, IRealpathOptions, IMkdirOptions, IReaddirOptions, IStatOptions, TData, TMode, TDataOut, Dirent, Stats, TStatNumber } from 'memfs';
 import type { PathLike, symlink } from 'fs';
 import type { Options, Pattern, Entry } from 'fast-glob';
 /**
@@ -45,7 +40,7 @@ export interface IVolumePartiallyMutable extends Omit<IVolume, 'reset' | 'fromJS
     __internal_do_not_use_addReadFileHook(hook: (filepath: PathLike, fileData: TDataOut) => Promise<TDataOut>): void;
 }
 export interface IUnionVolume extends Omit<IVolumeImmutable, 'promises'> {
-    promises: Pick<IVolumeImmutable, 'promises'> & {
+    promises: Omit<IVolumeImmutable['promises'], 'readFile'> & {
         /**
          * Reads a file
          * @param file Path

package/dist/WorkerData.d.ts

@@ -1,6 +1,4 @@
-import type { SerialiserModuleDefinition } from './SerialiserModuleDefinition';
-import type { PluginModuleDefinition } from './PluginModuleDefinition';
-import type { SourceModuleDefinition } from './SourceModuleDefinition';
+import type { SerialiserModuleDefinition, PluginModuleDefinition, SourceModuleDefinition, SourceSchedule } from './index.js';
 export declare type WorkerData<Options = {}> = {
     options: Options & Pick<PluginModuleDefinition, 'options'> & Pick<SourceModuleDefinition, 'options'> & {
         pageExtensions: string[];
@@ -12,4 +10,5 @@ export declare type WorkerData<Options = {}> = {
     plugins: PluginModuleDefinition[];
     serialisers: SerialiserModuleDefinition[];
     modulePath: string;
+    schedule: SourceSchedule;
 };

package/dist/index.d.ts

@@ -1,13 +1,15 @@
-export * from './IFileAccess';
-export * from './Meta';
-export * from './MutableData';
-export * from './Page';
-export * from './Plugin';
-export * from './PluginModuleDefinition';
-export * from './PullDocsConfig';
-export * from './Serialiser';
-export * from './SerialiserModuleDefinition';
-export * from './Source';
-export * from './SourceModuleDefinition';
-export * from './Volume';
-export * from './WorkerData';
+import type { SerialiserModuleDefinition, MosaicConfig, PluginModuleDefinition, SourceModuleDefinition, SourceWorkflow, SourceSchedule } from '@jpmorganchase/mosaic-schemas';
+export * from './Content.js';
+export * from './IFileAccess.js';
+export * from './Meta.js';
+export * from './MutableData.js';
+export * from './Page.js';
+export * from './Plugin.js';
+export * from './Serialiser.js';
+export * from './Source.js';
+export * from './Volume.js';
+export * from './WorkerData.js';
+export * from './Mode.js';
+export * from './Session.js';
+export * from './SourceWorkflow.js';
+export { SerialiserModuleDefinition, MosaicConfig, PluginModuleDefinition, SourceModuleDefinition, SourceWorkflow, SourceSchedule };

package/package.json

@@ -1,25 +1,36 @@
 {
   "name": "@jpmorganchase/mosaic-types",
-  "version": "0.1.0-beta.6",
-  "author": "",
+  "version": "0.1.0-beta.61",
   "description": "Mosaic BitBucket source for core file system",
   "license": "Apache-2.0",
+  "author": "",
+  "type": "module",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts"
+    }
+  },
   "engines": {
-    "node": ">= 12.0.0"
+    "node": ">=16.10.0 || >=18.0.0"
   },
   "repository": {
     "type": "git",
-    "url": "git@github.com:jpmorganchase/mosaic.git"
+    "url": "git@github.com:jpmorganchase/mosaic.git",
+    "directory": "packages/types"
   },
   "files": [
     "dist"
   ],
   "scripts": {
     "build": "tsc",
-    "clean": "rm -fr dist"
+    "clean": "rm -fr dist",
+    "lint": "eslint --ignore-pattern \"**/__tests__/**\""
   },
   "devDependencies": {
-    "rxjs": "^7.5.5"
+    "@jpmorganchase/mosaic-schemas": "^0.1.0-beta.61",
+    "memfs": "^3.4.12",
+    "rxjs": "^7.5.5",
+    "zod": "^3.22.3"
   }
 }

package/CHANGELOG.md

@@ -1,43 +0,0 @@
-# @jpmorganchase/mosaic-types
-
-## 0.1.0-beta.6
-
-### Patch Changes
-
-- c103b24: Release fixes for snapshot serve
-
-## 0.1.0-beta.5
-
-### Patch Changes
-
-- 61a246c: This releases add support for generate / build and serve snapshots
-
-## 0.1.0-beta.4
-
-### Patch Changes
-
-- bd285df: added dist to package.json
-
-## 0.1.0-beta.3
-
-### Patch Changes
-
-- 457df5e: switch to public package
-
-## 0.1.0-beta.2
-
-### Patch Changes
-
-- e1bbbe7: Initial release of Mosaic Core file-system.
-
-  Mosaic is a content aggregating service which pulls content from heterogeneous data sources.
-
-- 4b2bc51: pipped to 0.1.0-beta.1 for publishing to NPM
-
-## 0.1.0
-
-### Patch Changes
-
-- e1bbbe7: Initial release of Mosaic Core file-system.
-
-  Mosaic is a content aggregating service which pulls content from heterogeneous data sources.

package/dist/PluginModuleDefinition.d.ts

@@ -1,19 +0,0 @@
-export interface PluginModuleDefinition {
-    /**
-     * Options to pass to the plugin lifecycle methods.
-     */
-    options: Record<string, unknown>;
-    /**
-     * The importance of this plugin. This highest number plugin will be run first
-     */
-    priority?: number;
-    /**
-     * Exclude this plugin when running `mosaic build`
-     */
-    runTimeOnly?: boolean;
-    /**
-     * Path to the JS file for this plugin (can either export a `default` module with lifecycle methods,
-     * or export the methods individually)
-     */
-    modulePath: string;
-}

package/dist/PullDocsConfig.d.ts

@@ -1,10 +0,0 @@
-import type { PluginModuleDefinition } from './PluginModuleDefinition';
-import type { SerialiserModuleDefinition } from './SerialiserModuleDefinition';
-import type { SourceModuleDefinition } from './SourceModuleDefinition';
-export interface PullDocsConfig {
-    pageExtensions: Array<string>;
-    ignorePages?: Array<string>;
-    serialisers: Array<SerialiserModuleDefinition>;
-    plugins: Array<PluginModuleDefinition>;
-    sources: Array<SourceModuleDefinition>;
-}

package/dist/SerialiserModuleDefinition.d.ts

@@ -1,4 +0,0 @@
-import type { PluginModuleDefinition } from './PluginModuleDefinition';
-export declare type SerialiserModuleDefinition = PluginModuleDefinition & {
-    filter: RegExp;
-};

package/dist/SourceModuleDefinition.d.ts

@@ -1,5 +0,0 @@
-import type { PluginModuleDefinition } from './PluginModuleDefinition';
-export declare type SourceModuleDefinition = PluginModuleDefinition & {
-    namespace: string;
-    cache?: boolean;
-};