@jpmorganchase/mosaic-types 0.1.0-beta.9 → 0.1.0-beta.91

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,26 +1,12 @@
-/// <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';
 import type { Options, Pattern, Entry } from 'fast-glob';
+import type { DirectoryJSON, IFs } from 'memfs';
+import type { PathLike } 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
  */
-export interface IFileAccess {
+export interface IFileAccess extends Pick<IFs['promises'], 'mkdir' | 'readdir' | 'readFile' | 'realpath' | 'stat' | 'unlink' | 'symlink' | 'writeFile'> {
     glob(pattern: Pattern, options?: Omit<Options, 'absolute' | 'fs'>): Promise<string[] | Entry[]>;
-    mkdir(dir: PathLike, options?: TMode | IMkdirOptions): Promise<void>;
-    readdir(dir: PathLike, options?: string | IReaddirOptions): Promise<TDataOut[] | Dirent[]>;
-    readFile(file: PathLike): Promise<TDataOut>;
-    realpath(target: string, options?: string | IRealpathOptions): Promise<TDataOut>;
-    stat(file: PathLike, options?: IStatOptions): Promise<Stats<TStatNumber>>;
-    unlink(target: PathLike): Promise<void>;
-    symlink(target: PathLike, alias: PathLike, type?: symlink.Type): Promise<void>;
-    writeFile(file: PathLike, data: TData): Promise<void>;
     toJSON(): DirectoryJSON;
     fromJSON(json: DirectoryJSON): void;
     exists(file: PathLike): Promise<boolean>;

package/dist/Meta.d.ts

@@ -1,4 +1,4 @@
-export declare type Meta<AdditionalProps> = {
+export type Meta<AdditionalProps> = {
     title?: string;
     route: string;
     lastModified: Date;

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 type MosaicMode = 'active' | 'snapshot-file' | 'snapshot-s3';

package/dist/MutableData.d.ts

@@ -16,7 +16,7 @@ export interface BaseData {
     globalRefs?: GlobalRefs | [];
     aliases?: Aliases | [];
 }
-export declare type MutableData<T = {}> = ImmutableData<T> & {
+export type MutableData<T = {}> = ImmutableData<T> & {
     /**
      * Set arbitrary data onto the config object. This value will persist across plugins and
      * also be sent to the parent process when it executes plugins there as well.
@@ -63,7 +63,7 @@ export declare type MutableData<T = {}> = ImmutableData<T> & {
      */
     asReadOnly(): ImmutableData<T>;
 };
-export declare type ImmutableData<T = {}> = {
+export type ImmutableData<T = {}> = {
     readonly data: Readonly<T & {
         readonly refs: string[];
         readonly aliases: Set<{

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 = {
+export type Page = {
     fullPath: string;
     title?: string;
     /**

package/dist/Plugin.d.ts

@@ -1,16 +1,40 @@
-import type { Page } from './Page';
-import type { MutableData, ImmutableData } from './MutableData';
-import type { PluginModuleDefinition } from './index';
-import type { IUnionVolume, IVolumeImmutable, IVolumeMutable, IVolumePartiallyMutable } from './Volume';
-import type { Serialiser } from './Serialiser';
-export declare type LoadedPlugin = Partial<Plugin<Page>> & PluginModuleDefinition;
-export declare type LifecycleMethod = keyof Plugin<Page>;
+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 type LoadedPlugin = Partial<Plugin<Page>> & PluginModuleDefinition;
+export type LifecycleMethod = keyof Plugin<Page>;
+export 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 type PluginErrors = Array<PluginErrorDescriptor>;
+export 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<TPage extends Page = Page, TOptions = Record<string, unknown>, ConfigData = Record<string, unknown>, GlobalConfigData = ConfigData> = {
+export 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,6 +42,7 @@ export declare type Plugin<TPage extends Page = Page, TOptions = Record<string,
      * @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
      */
@@ -26,6 +51,7 @@ export declare type Plugin<TPage extends Page = Page, TOptions = Record<string,
         config: MutableData<ConfigData>;
         pageExtensions: string[];
         ignorePages: string[];
+        namespace: string;
     }, options?: TOptions) => Promise<Array<TPage>>;
     /**
      * Plugin lifecycle method that triggers inside child processes.
@@ -33,6 +59,7 @@ export declare type Plugin<TPage extends Page = Page, TOptions = Record<string,
      * @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
      */
@@ -41,6 +68,7 @@ export declare type Plugin<TPage extends Page = Page, TOptions = Record<string,
         pageExtensions: string[];
         ignorePages: string[];
         config: MutableData<ConfigData>;
+        namespace: string;
     }, options?: TOptions) => Promise<void>;
     /**
      * Plugin lifecycle method that triggers inside the main process.
@@ -56,6 +84,7 @@ export declare type Plugin<TPage extends Page = Page, TOptions = Record<string,
      * @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
      */
@@ -67,6 +96,7 @@ export declare type Plugin<TPage extends Page = Page, TOptions = Record<string,
         globalConfig: ImmutableData<GlobalConfigData>;
         pageExtensions: string[];
         ignorePages: string[];
+        namespace: string;
     }, options?: TOptions) => Promise<void>;
     /**
      * Plugin lifecycle method that triggers inside the main process everytime ANY source emits new pages.
@@ -77,6 +107,7 @@ export declare type Plugin<TPage extends Page = Page, TOptions = Record<string,
      * @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
      */
@@ -86,28 +117,54 @@ export declare type Plugin<TPage extends Page = Page, TOptions = Record<string,
         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
+     */
+    shouldUpdateNamespaceSources?: (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 whenever a request to save content is made.
-     * This method should return the result of the save
-     * Returning `undefined`, false or no value, will result in the plugin runner discarding the result.
-     * @param path the route of the content being edited.
-     * @param data the data from the the request
-     * @param sourceOptions options used to create the source that is running the plugin
+     * 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 {Promise<unknown>} The result of the save
+     * @returns {void} No return expected
      */
-    saveContent?(path: string, data: unknown, sourceOptions: unknown, helpers: {
+    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<unknown>;
+    }, options?: TOptions) => Promise<void>;
 };

package/dist/Serialiser.d.ts

@@ -1,13 +1,13 @@
-import type { TDataOut } from 'memfs/lib/encoding';
-import type { SerialiserModuleDefinition } from './index';
-import type { Page } from './Page';
+import type { SerialiserModuleDefinition } from './index.js';
+import type { Page } from './Page.js';
+import type { TDataOut } from './Volume.js';
 /**
  * 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 Mosaic config file, to find a suitable parser.
  */
-export declare type Serialiser<TPage extends Page = Page> = {
+export 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)
@@ -23,4 +23,4 @@ export declare type Serialiser<TPage extends Page = Page> = {
      */
     serialise: (fullPath: string, page: TPage) => Promise<TDataOut>;
 };
-export declare type LoadedSerialiser = Serialiser & SerialiserModuleDefinition;
+export type LoadedSerialiser = Serialiser & SerialiserModuleDefinition;

package/dist/Session.d.ts

@@ -0,0 +1,22 @@
+export 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 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 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 type Source<TOptions = Record<string, unknown>, TPage extends Page = Page> = {
+    create(options: TOptions, helpers: SourceConfig): Observable<TPage[]>;
 };

package/dist/SourceWorkflow.d.ts

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

package/dist/Volume.d.ts

@@ -1,12 +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 { DirectoryJSON, IFs } from 'memfs';
+import type { PathLike } from 'fs';
 import type { Options, Pattern, Entry } from 'fast-glob';
+type TDataOut = string | Buffer;
+export type { TDataOut };
 /**
  * Volumes are lightweight decorators which wrap `FileAccess` and limit access to the underlying API for different use-cases
  * Examples include disallowing mutation or allowing underlying functions like resetting
@@ -22,17 +18,9 @@ export interface IVolume {
         }[];
     };
     fromJSON?(json: DirectoryJSON): void;
-    promises: {
+    promises: Pick<IFs['promises'], 'mkdir' | 'readdir' | 'readFile' | 'realpath' | 'stat' | 'symlink' | 'unlink' | 'writeFile'> & {
         exists(file: PathLike): Promise<boolean>;
         glob(pattern: Pattern, options?: Options): Promise<string[] | Entry[]>;
-        mkdir(dir: PathLike, options?: TMode | IMkdirOptions): Promise<void>;
-        readdir(dir: PathLike, options?: string | IReaddirOptions): Promise<TDataOut[] | Dirent[]>;
-        readFile(file: PathLike): Promise<TDataOut>;
-        realpath(target: string, options?: string | IRealpathOptions): Promise<TDataOut>;
-        stat(file: PathLike, options?: IStatOptions): Promise<Stats<TStatNumber>>;
-        symlink(target: PathLike, alias: PathLike, type?: symlink.Type): Promise<void>;
-        unlink(target: PathLike): Promise<void>;
-        writeFile(file: PathLike, data: TData): Promise<void>;
     };
 }
 export interface IVolumePartiallyMutable extends Omit<IVolume, 'reset' | 'fromJSON'> {
@@ -45,7 +33,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,5 +1,5 @@
-import type { SerialiserModuleDefinition, PluginModuleDefinition, SourceModuleDefinition } from './index';
-export declare type WorkerData<Options = {}> = {
+import type { SerialiserModuleDefinition, PluginModuleDefinition, SourceModuleDefinition, SourceSchedule } from './index.js';
+export type WorkerData<Options = {}> = {
     options: Options & Pick<PluginModuleDefinition, 'options'> & Pick<SourceModuleDefinition, 'options'> & {
         pageExtensions: string[];
     };
@@ -10,4 +10,5 @@ export declare type WorkerData<Options = {}> = {
     plugins: PluginModuleDefinition[];
     serialisers: SerialiserModuleDefinition[];
     modulePath: string;
+    schedule: SourceSchedule;
 };

package/dist/index.d.ts

@@ -1,11 +1,15 @@
-import type { SerialiserModuleDefinition, MosaicConfig, PluginModuleDefinition, SourceModuleDefinition, SourceWorkflow } from '@jpmorganchase/mosaic-schemas';
-export * from './IFileAccess';
-export * from './Meta';
-export * from './MutableData';
-export * from './Page';
-export * from './Plugin';
-export * from './Serialiser';
-export * from './Source';
-export * from './Volume';
-export * from './WorkerData';
-export { SerialiserModuleDefinition, MosaicConfig, PluginModuleDefinition, SourceModuleDefinition, SourceWorkflow };
+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,27 +1,36 @@
 {
   "name": "@jpmorganchase/mosaic-types",
-  "version": "0.1.0-beta.9",
-  "author": "",
+  "version": "0.1.0-beta.91",
   "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": ">=18.0.0 || >=20.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": {
-    "@jpmorganchase/mosaic-schemas": "^0.1.0-beta.9",
+    "@jpmorganchase/mosaic-schemas": "^0.1.0-beta.91",
+    "memfs": "^4.0.0",
     "rxjs": "^7.5.5",
-    "zod": "^3.19.1"
+    "zod": "^3.22.3"
   }
 }

package/CHANGELOG.md

@@ -1,70 +0,0 @@
-# @jpmorganchase/mosaic-types
-
-## 0.1.0-beta.9
-
-### Minor Changes
-
-- c3fee89: initial components package
-
-  - added JSDOM testing
-
-## 0.1.0-beta.8
-
-### Minor Changes
-
-- 2dca0b1: initial release of Mosaic store package
-
-## 0.1.0-beta.7
-
-### Minor Changes
-
-- f82c397: Initial release of theme and client side search
-
-  We are iterating towards deploying our site code.
-
-  This release includes
-
-  - initial work for client-side search support
-  - Mosaic theme.
-
-## 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.