@blue-labs/language 1.20.0

package/dist/lib/mapping/__tests__/schema/y1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"y1.d.ts","sourceRoot":"","sources":["../../../../../src/lib/mapping/__tests__/schema/y1.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAMpB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMpB,CAAC"}

package/dist/lib/mapping/index.d.ts

@@ -0,0 +1,4 @@
+export { NodeToObjectConverter } from './NodeToObjectConverter';
+export type { Converter } from './Converter';
+export { ConverterFactory } from './ConverterFactory';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/mapping/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/mapping/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/lib/mapping/serializeBlueAnnotated.d.ts

@@ -0,0 +1,3 @@
+import { ZodType, ZodTypeDef, AnyZodObject } from 'zod';
+export declare function serializeBlueAnnotated<T extends Record<string, unknown>>(value: T, schema: AnyZodObject | ZodType<T, ZodTypeDef, T>): Record<string, unknown>;
+//# sourceMappingURL=serializeBlueAnnotated.d.ts.map

package/dist/lib/mapping/serializeBlueAnnotated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeBlueAnnotated.d.ts","sourceRoot":"","sources":["../../../src/lib/mapping/serializeBlueAnnotated.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAa,UAAU,EAAE,YAAY,EAAE,MAAM,KAAK,CAAC;AAUnE,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACtE,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,GAC/C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuGzB"}

package/dist/lib/model/BigDecimalNumber.d.ts

@@ -0,0 +1,9 @@
+import { default as Big } from 'big.js';
+/**
+ * BigDecimalNumber class extends the Big.js library to handle large float values.
+ * Created to make it similar to Java's implementation in the Blue language.
+ */
+export declare class BigDecimalNumber extends Big {
+    constructor(value: number | string);
+}
+//# sourceMappingURL=BigDecimalNumber.d.ts.map

package/dist/lib/model/BigDecimalNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BigDecimalNumber.d.ts","sourceRoot":"","sources":["../../../src/lib/model/BigDecimalNumber.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,QAAQ,CAAC;AAEzB;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,GAAG;gBAC3B,KAAK,EAAE,MAAM,GAAG,MAAM;CAGnC"}

package/dist/lib/model/BigIntegerNumber.d.ts

@@ -0,0 +1,9 @@
+import { default as Big } from 'big.js';
+/**
+ * BigIntegerNumber class extends the Big.js library to handle large integer values.
+ * Created to make it similar to Java's implementation in the Blue language.
+ */
+export declare class BigIntegerNumber extends Big {
+    constructor(value: number | string);
+}
+//# sourceMappingURL=BigIntegerNumber.d.ts.map

package/dist/lib/model/BigIntegerNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BigIntegerNumber.d.ts","sourceRoot":"","sources":["../../../src/lib/model/BigIntegerNumber.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,QAAQ,CAAC;AAEzB;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,GAAG;gBAC3B,KAAK,EAAE,MAAM,GAAG,MAAM;CAGnC"}

package/dist/lib/model/Node.d.ts

@@ -0,0 +1,53 @@
+import { JsonPrimitive } from '@blue-labs/shared-utils';
+import { BigIntegerNumber } from './BigIntegerNumber';
+import { BigDecimalNumber } from './BigDecimalNumber';
+export declare class BlueNode {
+    static INTEGER: BlueNode;
+    private name?;
+    private description?;
+    private type?;
+    private itemType?;
+    private keyType?;
+    private valueType?;
+    private value?;
+    private items?;
+    private properties?;
+    private contracts?;
+    private blueId?;
+    private blue?;
+    private inlineValue;
+    constructor(name?: string);
+    getName(): string | undefined;
+    setName(name: string | undefined): BlueNode;
+    getDescription(): string | undefined;
+    setDescription(description: string | undefined): BlueNode;
+    getType(): BlueNode | undefined;
+    setType(type: BlueNode | string | undefined): BlueNode;
+    getItemType(): BlueNode | undefined;
+    setItemType(itemType: BlueNode | string | undefined): BlueNode;
+    getKeyType(): BlueNode | undefined;
+    setKeyType(keyType: BlueNode | string | undefined): BlueNode;
+    getValueType(): BlueNode | undefined;
+    setValueType(valueType: BlueNode | string | undefined): BlueNode;
+    getValue(): string | boolean | BigIntegerNumber | BigDecimalNumber | null | undefined;
+    setValue(value: JsonPrimitive | BigIntegerNumber | BigDecimalNumber | number): BlueNode;
+    getItems(): BlueNode[] | undefined;
+    setItems(items: BlueNode[] | undefined): BlueNode;
+    addItems(...items: BlueNode[]): BlueNode;
+    getProperties(): Record<string, BlueNode> | undefined;
+    setProperties(properties: Record<string, BlueNode> | undefined): BlueNode;
+    addProperty(key: string, value: BlueNode): BlueNode;
+    getContracts(): Record<string, BlueNode> | undefined;
+    setContracts(contracts: Record<string, BlueNode> | undefined): BlueNode;
+    addContract(key: string, value: BlueNode): BlueNode;
+    getBlueId(): string | undefined;
+    setBlueId(blueId: string | undefined): BlueNode;
+    getBlue(): BlueNode | undefined;
+    setBlue(blue: BlueNode | undefined): BlueNode;
+    isInlineValue(): boolean;
+    setInlineValue(inlineValue: boolean): BlueNode;
+    get(path: string, linkingProvider?: (node: BlueNode) => BlueNode | null): BlueNode | string | boolean | BigIntegerNumber | BigDecimalNumber | null | undefined;
+    clone(): BlueNode;
+    toString(): string;
+}
+//# sourceMappingURL=Node.d.ts.map

package/dist/lib/model/Node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Node.d.ts","sourceRoot":"","sources":["../../../src/lib/model/Node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAEvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAOtD,qBAAa,QAAQ;IACnB,MAAM,CAAC,OAAO,EAAE,QAAQ,CAA2B;IAEnD,OAAO,CAAC,IAAI,CAAC,CAAS;IACtB,OAAO,CAAC,WAAW,CAAC,CAAS;IAC7B,OAAO,CAAC,IAAI,CAAC,CAAW;IACxB,OAAO,CAAC,QAAQ,CAAC,CAAW;IAC5B,OAAO,CAAC,OAAO,CAAC,CAAW;IAC3B,OAAO,CAAC,SAAS,CAAC,CAAW;IAC7B,OAAO,CAAC,KAAK,CAAC,CAGO;IACrB,OAAO,CAAC,KAAK,CAAC,CAAa;IAC3B,OAAO,CAAC,UAAU,CAAC,CAA2B;IAC9C,OAAO,CAAC,SAAS,CAAC,CAA2B;IAC7C,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,IAAI,CAAC,CAAW;IACxB,OAAO,CAAC,WAAW,CAAS;gBAEhB,IAAI,CAAC,EAAE,MAAM;IAIzB,OAAO;IAIP,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ;IAK3C,cAAc;IAId,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ;IAKzD,OAAO;IAIP,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ;IAStD,WAAW;IAIX,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ;IAS9D,UAAU;IAIV,UAAU,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ;IAS5D,YAAY;IAIZ,YAAY,CAAC,SAAS,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ;IAShE,QAAQ;IAyBR,QAAQ,CACN,KAAK,EAAE,aAAa,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,MAAM,GAClE,QAAQ;IAaX,QAAQ;IAIR,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,SAAS,GAAG,QAAQ;IAKjD,QAAQ,CAAC,GAAG,KAAK,EAAE,QAAQ,EAAE,GAAG,QAAQ;IAQxC,aAAa;IAIb,aAAa,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,SAAS,GAAG,QAAQ;IAKzE,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,QAAQ;IAQnD,YAAY;IAIZ,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,SAAS,GAAG,QAAQ;IAKvE,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,QAAQ;IAQnD,SAAS;IAIT,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ;IAK/C,OAAO;IAIP,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,QAAQ;IAK7C,aAAa;IAIb,cAAc,CAAC,WAAW,EAAE,OAAO,GAAG,QAAQ;IAK9C,GAAG,CACD,IAAI,EAAE,MAAM,EACZ,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,QAAQ,GAAG,IAAI,GAEnD,QAAQ,GACR,MAAM,GACN,OAAO,GACP,gBAAgB,GAChB,gBAAgB,GAChB,IAAI,GACJ,SAAS;IAIb,KAAK,IAAI,QAAQ;IAyBjB,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/lib/model/NodeDeserializer.d.ts

@@ -0,0 +1,8 @@
+import { BlueNode } from './Node';
+export declare class NodeDeserializer {
+    static deserialize(json: unknown): BlueNode;
+    private static handleNode;
+    private static handleValue;
+    private static handleArray;
+}
+//# sourceMappingURL=NodeDeserializer.d.ts.map

package/dist/lib/model/NodeDeserializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeDeserializer.d.ts","sourceRoot":"","sources":["../../../src/lib/model/NodeDeserializer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAqBlC,qBAAa,gBAAgB;IAC3B,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,OAAO;IAIhC,OAAO,CAAC,MAAM,CAAC,UAAU;IA2FzB,OAAO,CAAC,MAAM,CAAC,WAAW;IA2B1B,OAAO,CAAC,MAAM,CAAC,WAAW;CAY3B"}

package/dist/lib/model/index.d.ts

@@ -0,0 +1,5 @@
+export { BlueNode } from './Node';
+export { NodeDeserializer } from './NodeDeserializer';
+export { BigDecimalNumber } from './BigDecimalNumber';
+export { BigIntegerNumber } from './BigIntegerNumber';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/model/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/model/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAClC,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/lib/preprocess/BlueDirectivePreprocessor.d.ts

@@ -0,0 +1,85 @@
+import { BlueNode } from '../model';
+import { UrlContentFetcher } from '../provider/UrlContentFetcher';
+/**
+ * A preprocessor specifically for handling blue directives before main preprocessing
+ */
+export declare class BlueDirectivePreprocessor {
+    private preprocessingAliases;
+    private urlContentFetcher?;
+    /**
+     * Creates a new BlueDirectivePreprocessor
+     *
+     * @param preprocessingAliases - Map of alias values to BlueIds (optional)
+     * @param urlContentFetcher - UrlContentFetcher for fetching URL content
+     */
+    constructor(preprocessingAliases?: Map<string, string>, urlContentFetcher?: UrlContentFetcher);
+    /**
+     * Processes a node's blue directive synchronously
+     *
+     * @param node - The node to process
+     * @returns The node with processed blue directive
+     */
+    process(node: BlueNode): BlueNode;
+    /**
+     * Processes a node's blue directive asynchronously, with support for URL fetching
+     *
+     * @param node - The node to process
+     * @returns Promise that resolves to the node with processed blue directive
+     */
+    processAsync(node: BlueNode): Promise<BlueNode>;
+    /**
+     * Gets the blue node value if it exists and is a string
+     * @param node - The node to get the blue value from
+     * @returns The blue node value or null if it doesn't exist or isn't a string
+     */
+    private getBlueNodeValue;
+    /**
+     * Handles a blue value that is an alias
+     * @param node - The cloned node to modify
+     * @param value - The alias value
+     * @returns The modified node
+     */
+    private handleAliasValue;
+    /**
+     * Handles a blue value that is a potential BlueId
+     * @param node - The cloned node to modify
+     * @param value - The BlueId value
+     * @returns The modified node
+     */
+    private handleBlueId;
+    /**
+     * Fetches content from a URL
+     * @param url - The URL to fetch from
+     * @returns Promise that resolves to the fetched BlueNodes or null if fetch fails
+     */
+    private fetchFromUrl;
+    /**
+     * Gets the current preprocessing aliases
+     * @returns Map of aliases to BlueIds
+     */
+    getPreprocessingAliases(): Map<string, string>;
+    /**
+     * Sets the preprocessing aliases
+     * @param aliases - Map of aliases to set
+     * @returns this instance for chaining
+     */
+    setPreprocessingAliases(aliases: Map<string, string>): BlueDirectivePreprocessor;
+    /**
+     * Adds preprocessing aliases to the map
+     * @param aliases - Map of aliases to add
+     * @returns this instance for chaining
+     */
+    addPreprocessingAliases(aliases: Map<string, string>): BlueDirectivePreprocessor;
+    /**
+     * Updates the URL content fetcher
+     * @param urlContentFetcher - The UrlContentFetcher to use
+     * @returns this instance for chaining
+     */
+    setUrlContentFetcher(urlContentFetcher: UrlContentFetcher): BlueDirectivePreprocessor;
+    /**
+     * Gets the current URL content fetcher
+     * @returns The current UrlContentFetcher or undefined
+     */
+    getUrlContentFetcher(): UrlContentFetcher | undefined;
+}
+//# sourceMappingURL=BlueDirectivePreprocessor.d.ts.map

package/dist/lib/preprocess/BlueDirectivePreprocessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlueDirectivePreprocessor.d.ts","sourceRoot":"","sources":["../../../src/lib/preprocess/BlueDirectivePreprocessor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAElE;;GAEG;AACH,qBAAa,yBAAyB;IACpC,OAAO,CAAC,oBAAoB,CAAkC;IAC9D,OAAO,CAAC,iBAAiB,CAAC,CAAoB;IAE9C;;;;;OAKG;gBAED,oBAAoB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,iBAAiB,CAAC,EAAE,iBAAiB;IAQvC;;;;;OAKG;IACI,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ;IAsBxC;;;;;OAKG;IACU,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAqC5D;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAQxB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAOxB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAKpB;;;;OAIG;YACW,YAAY;IAQ1B;;;OAGG;IACI,uBAAuB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAIrD;;;;OAIG;IACI,uBAAuB,CAC5B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3B,yBAAyB;IAK5B;;;;OAIG;IACI,uBAAuB,CAC5B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3B,yBAAyB;IAO5B;;;;OAIG;IACI,oBAAoB,CACzB,iBAAiB,EAAE,iBAAiB,GACnC,yBAAyB;IAK5B;;;OAGG;IACI,oBAAoB,IAAI,iBAAiB,GAAG,SAAS;CAG7D"}

package/dist/lib/preprocess/Preprocessor.d.ts

@@ -0,0 +1,68 @@
+import { NodeProvider } from '../NodeProvider';
+import { BlueNode } from '../model';
+import { TransformationProcessorProvider } from './interfaces';
+import { BlueIdsRecord } from './utils/BlueIdsMappingGenerator';
+/**
+ * Preprocessor class for transforming BlueNodes
+ */
+export declare class Preprocessor {
+    static readonly DEFAULT_BLUE_BLUE_ID = "FREHAAGDZSzpnoTUoCQ86bBmxbVCULMjvx9JZM6fyqT1";
+    private processorProvider;
+    private nodeProvider;
+    private defaultSimpleBlue;
+    /**
+     * Creates a new Preprocessor with the specified provider and NodeProvider or just NodeProvider
+     * @param processorProviderOrNodeProvider - The TransformationProcessorProvider or NodeProvider to use
+     * @param nodeProvider - The NodeProvider to use for resolving nodes (optional)
+     */
+    constructor(processorProviderOrNodeProvider: TransformationProcessorProvider | NodeProvider, nodeProvider?: NodeProvider);
+    /**
+     * Registers additional BlueIds collections for dynamic mapping generation
+     * @param blueIdsCollections - Array of BlueIds objects to register
+     */
+    static registerBlueIds(...blueIdsCollections: BlueIdsRecord[]): void;
+    /**
+     * Resets BlueIds collections to defaults (core and myos only)
+     */
+    static resetBlueIdsToDefaults(): void;
+    /**
+     * Gets all currently registered BlueIds
+     * @returns Merged object containing all BlueIds from all collections
+     */
+    static getAllRegisteredBlueIds(): Record<string, string>;
+    /**
+     * Preprocesses a document node
+     * @param document - The document node to preprocess
+     * @returns The preprocessed document
+     */
+    preprocess(document: BlueNode): BlueNode;
+    /**
+     * Preprocesses a document node using the default Blue node
+     * @param document - The document node to preprocess
+     * @returns The preprocessed document
+     */
+    preprocessWithDefaultBlue(document: BlueNode): BlueNode;
+    /**
+     * Preprocesses a document node with the specified default Blue node
+     * @param document - The document node to preprocess
+     * @param defaultBlue - The default Blue node to use if the document doesn't have one
+     * @returns The preprocessed document
+     */
+    private preprocessWithOptions;
+    /**
+     * Gets the standard transformation processor provider
+     * @returns The standard provider
+     */
+    static getStandardProvider(): TransformationProcessorProvider;
+    /**
+     * Enriches the default Blue YAML with dynamic BlueIds mappings
+     * @param defaultBlue - The base default Blue YAML content
+     * @returns Enriched YAML content with dynamic mappings
+     */
+    private enrichDefaultBlue;
+    /**
+     * Loads the default simple Blue node
+     */
+    private loadDefaultSimpleBlue;
+}
+//# sourceMappingURL=Preprocessor.d.ts.map

package/dist/lib/preprocess/Preprocessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Preprocessor.d.ts","sourceRoot":"","sources":["../../../src/lib/preprocess/Preprocessor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAIpC,OAAO,EAEL,+BAA+B,EAChC,MAAM,cAAc,CAAC;AAUtB,OAAO,EAEL,KAAK,aAAa,EACnB,MAAM,iCAAiC,CAAC;AAEzC;;GAEG;AACH,qBAAa,YAAY;IACvB,gBAAuB,oBAAoB,kDACM;IAEjD,OAAO,CAAC,iBAAiB,CAAkC;IAC3D,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,iBAAiB,CAAyB;IAElD;;;;OAIG;gBAED,+BAA+B,EAC3B,+BAA+B,GAC/B,YAAY,EAChB,YAAY,CAAC,EAAE,YAAY;IAqB7B;;;OAGG;WACW,eAAe,CAAC,GAAG,kBAAkB,EAAE,aAAa,EAAE,GAAG,IAAI;IAI3E;;OAEG;WACW,sBAAsB,IAAI,IAAI;IAK5C;;;OAGG;WACW,uBAAuB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAI/D;;;;OAIG;IACI,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ;IAI/C;;;;OAIG;IACI,yBAAyB,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ;IAI9D;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAqC7B;;;OAGG;WACW,mBAAmB,IAAI,+BAA+B;IAyBpE;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IASzB;;OAEG;IACH,OAAO,CAAC,qBAAqB;CAa9B"}

package/dist/lib/preprocess/index.d.ts

@@ -0,0 +1,5 @@
+export { type TransformationProcessor, type TransformationProcessorProvider, } from './interfaces';
+export { InferBasicTypesForUntypedValues, ReplaceInlineValuesForTypeAttributesWithImports, } from './processor';
+export { Preprocessor } from './Preprocessor';
+export { BlueDirectivePreprocessor } from './BlueDirectivePreprocessor';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/preprocess/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/preprocess/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,+BAA+B,GACrC,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,+BAA+B,EAC/B,+CAA+C,GAChD,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/lib/preprocess/interfaces.d.ts

@@ -0,0 +1,24 @@
+import { BlueNode } from '../model';
+/**
+ * Interface for processors that transform BlueNodes
+ */
+export interface TransformationProcessor {
+    /**
+     * Process a document node
+     * @param document - The document to process
+     * @returns The processed document
+     */
+    process(document: BlueNode): BlueNode;
+}
+/**
+ * Provider interface for transformation processors
+ */
+export interface TransformationProcessorProvider {
+    /**
+     * Get a processor for the given transformation node
+     * @param transformation - The transformation node
+     * @returns The processor, or undefined if no processor is available
+     */
+    getProcessor(transformation: BlueNode): TransformationProcessor | undefined;
+}
+//# sourceMappingURL=interfaces.d.ts.map

package/dist/lib/preprocess/interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../../src/lib/preprocess/interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;OAIG;IACH,OAAO,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC9C;;;;OAIG;IACH,YAAY,CAAC,cAAc,EAAE,QAAQ,GAAG,uBAAuB,GAAG,SAAS,CAAC;CAC7E"}

package/dist/lib/preprocess/processor/InferBasicTypesForUntypedValues.d.ts

@@ -0,0 +1,20 @@
+import { BlueNode } from '../../model';
+import { TransformationProcessor } from '../interfaces';
+/**
+ * Processor that infers basic types for untyped values
+ */
+export declare class InferBasicTypesForUntypedValues implements TransformationProcessor {
+    /**
+     * Process a document node to infer basic types for untyped values
+     * @param document - The document to process
+     * @returns The processed document
+     */
+    process(document: BlueNode): BlueNode;
+    /**
+     * Infer a basic type for a node
+     * @param node - The node to infer a type for
+     * @returns The node with the inferred type
+     */
+    private inferType;
+}
+//# sourceMappingURL=InferBasicTypesForUntypedValues.d.ts.map

package/dist/lib/preprocess/processor/InferBasicTypesForUntypedValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InferBasicTypesForUntypedValues.d.ts","sourceRoot":"","sources":["../../../../src/lib/preprocess/processor/InferBasicTypesForUntypedValues.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAcxD;;GAEG;AACH,qBAAa,+BACX,YAAW,uBAAuB;IAElC;;;;OAIG;IACH,OAAO,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ;IAIrC;;;;OAIG;IACH,OAAO,CAAC,SAAS;CAkBlB"}

package/dist/lib/preprocess/processor/ReplaceInlineValuesForTypeAttributesWithImports.d.ts

@@ -0,0 +1,23 @@
+import { BlueNode } from '../../model';
+import { TransformationProcessor } from '../interfaces';
+/**
+ * Processor that replaces inline values for type attributes with imports
+ */
+export declare class ReplaceInlineValuesForTypeAttributesWithImports implements TransformationProcessor {
+    static readonly MAPPINGS = "mappings";
+    private mappings;
+    /**
+     * Creates a new processor with the given transformation node or mappings
+     * @param transformationOrMappings - The transformation node or mappings to use
+     */
+    constructor(transformationOrMappings: BlueNode | Map<string, string>);
+    /**
+     * Process a document node to replace inline values for type attributes with imports
+     * @param document - The document to process
+     * @returns The processed document
+     */
+    process(document: BlueNode): BlueNode;
+    private transformNode;
+    private transformTypeField;
+}
+//# sourceMappingURL=ReplaceInlineValuesForTypeAttributesWithImports.d.ts.map

package/dist/lib/preprocess/processor/ReplaceInlineValuesForTypeAttributesWithImports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReplaceInlineValuesForTypeAttributesWithImports.d.ts","sourceRoot":"","sources":["../../../../src/lib/preprocess/processor/ReplaceInlineValuesForTypeAttributesWithImports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAGxD;;GAEG;AACH,qBAAa,+CACX,YAAW,uBAAuB;IAElC,gBAAuB,QAAQ,cAAc;IAC7C,OAAO,CAAC,QAAQ,CAAkC;IAElD;;;OAGG;gBACS,wBAAwB,EAAE,QAAQ,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IA2BpE;;;;OAIG;IACH,OAAO,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ;IAIrC,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,kBAAkB;CA6B3B"}

package/dist/lib/preprocess/processor/index.d.ts

@@ -0,0 +1,3 @@
+export * from './InferBasicTypesForUntypedValues';
+export * from './ReplaceInlineValuesForTypeAttributesWithImports';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/preprocess/processor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/preprocess/processor/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,mDAAmD,CAAC"}

package/dist/lib/preprocess/utils/BlueIdsMappingGenerator.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Type definition for BlueIds objects
+ */
+export type BlueIdsRecord = Record<string, string>;
+/**
+ * Utility class for generating YAML mappings from BlueIds objects
+ * This class provides a centralized way to manage and generate YAML mappings
+ * from various BlueIds collections, making it easy to extend with new collections.
+ */
+export declare class BlueIdsMappingGenerator {
+    private static blueIdsCollections;
+    /**
+     * Initializes the generator with default BlueIds collections
+     * @param defaultCollections - Array of default BlueIds objects to initialize with
+     */
+    static initialize(...defaultCollections: BlueIdsRecord[]): void;
+    /**
+     * Registers additional BlueIds collections for mapping generation
+     * @param blueIdsCollections - Array of BlueIds objects to register
+     */
+    static registerBlueIds(...blueIdsCollections: BlueIdsRecord[]): void;
+    /**
+     * Generates YAML mappings section from all registered BlueIds collections
+     * @param transformationBlueId - The BlueId for the transformation type (defaults to the standard one)
+     * @returns YAML string with mappings for all BlueIds
+     */
+    static generateMappingsYaml(transformationBlueId?: string): string;
+    /**
+     * Gets all currently registered BlueIds as a merged object
+     * @returns Merged object containing all BlueIds from all collections
+     */
+    static getAllBlueIds(): Record<string, string>;
+    /**
+     * Gets the names of all registered BlueIds
+     * @returns Array of all BlueId names
+     */
+    static getAllBlueIdNames(): string[];
+    /**
+     * Clears all registered BlueIds collections
+     */
+    static clear(): void;
+    /**
+     * Gets the count of registered BlueIds collections
+     * @returns Number of registered collections
+     */
+    static getCollectionCount(): number;
+    /**
+     * Gets the total count of unique BlueIds across all collections
+     * @returns Number of unique BlueIds
+     */
+    static getTotalBlueIdCount(): number;
+}
+//# sourceMappingURL=BlueIdsMappingGenerator.d.ts.map

package/dist/lib/preprocess/utils/BlueIdsMappingGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlueIdsMappingGenerator.d.ts","sourceRoot":"","sources":["../../../../src/lib/preprocess/utils/BlueIdsMappingGenerator.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEnD;;;;GAIG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAuB;IAExD;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,kBAAkB,EAAE,aAAa,EAAE,GAAG,IAAI;IAI/D;;;OAGG;IACH,MAAM,CAAC,eAAe,CAAC,GAAG,kBAAkB,EAAE,aAAa,EAAE,GAAG,IAAI;IAIpE;;;;OAIG;IACH,MAAM,CAAC,oBAAoB,CACzB,oBAAoB,SAAiD,GACpE,MAAM;IAmBT;;;OAGG;IACH,MAAM,CAAC,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAU9C;;;OAGG;IACH,MAAM,CAAC,iBAAiB,IAAI,MAAM,EAAE;IAIpC;;OAEG;IACH,MAAM,CAAC,KAAK,IAAI,IAAI;IAIpB;;;OAGG;IACH,MAAM,CAAC,kBAAkB,IAAI,MAAM;IAInC;;;OAGG;IACH,MAAM,CAAC,mBAAmB,IAAI,MAAM;CAGrC"}

package/dist/lib/processor/BlueDocumentProcessor.d.ts

@@ -0,0 +1,54 @@
+import { ContractProcessor, DocumentNode, EventNodePayload, ProcessingResult } from './types';
+import { Blue } from '../Blue';
+/**
+ * BlueDocumentProcessor - Main orchestrator for document processing
+ *
+ * Orchestrates the document processing pipeline, managing state transitions
+ * and event propagation through the registered contract processors.
+ */
+export declare class BlueDocumentProcessor {
+    private readonly blue;
+    private taskCounter;
+    private eventCounter;
+    private readonly registry;
+    private readonly queue;
+    private readonly router;
+    private readonly checkpointCache;
+    /**
+     * Creates a new document processor
+     *
+     * @param processors - Initial list of processors to register
+     */
+    constructor(blue: Blue, processors?: ContractProcessor[]);
+    /**
+     * Registers a new contract processor
+     *
+     * @param cp - The processor to register
+     * @param orderHint - Optional priority value for execution order
+     */
+    register(cp: ContractProcessor, orderHint?: number): void;
+    /**
+     * Initializes a document and runs all init events
+     *
+     * @param document - The document to initialize
+     * @returns Processing result with final state and emitted events
+     */
+    initialise(document: DocumentNode): Promise<ProcessingResult>;
+    /**
+     * Processes a batch of events against the document
+     *
+     * @param document - The document to process events against
+     * @param incoming - List of event payloads to process
+     * @returns Processing result with final state and emitted events
+     */
+    processEvents(document: DocumentNode, incoming: EventNodePayload[]): Promise<ProcessingResult>;
+    /**
+     * Collects initialization events from contract processors
+     */
+    private bootstrapContracts;
+    /**
+     * Drains the task queue and applies all actions
+     */
+    private drainQueue;
+}
+//# sourceMappingURL=BlueDocumentProcessor.d.ts.map

package/dist/lib/processor/BlueDocumentProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlueDocumentProcessor.d.ts","sourceRoot":"","sources":["../../../src/lib/processor/BlueDocumentProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,YAAY,EAEZ,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAYjB,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE/B;;;;;GAKG;AACH,qBAAa,qBAAqB;IAc9B,OAAO,CAAC,QAAQ,CAAC,IAAI;IAbvB,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAC5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAyB;IAEzD;;;;OAIG;gBAEgB,IAAI,EAAE,IAAI,EAC3B,UAAU,GAAE,iBAAiB,EAAO;IAkBtC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,EAAE,iBAAiB,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAIzD;;;;;OAKG;IACG,UAAU,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAYnE;;;;;;OAMG;IACG,aAAa,CACjB,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,gBAAgB,EAAE,GAC3B,OAAO,CAAC,gBAAgB,CAAC;IAyB5B;;OAEG;YACW,kBAAkB;IAoBhC;;OAEG;YACW,UAAU;CAmFzB"}

package/dist/lib/processor/context.d.ts

@@ -0,0 +1,21 @@
+import { DocumentNode, ProcessingContext, Patch, EventNode, ProcessingAction, HandlerTask } from './types';
+import { Blue } from '../Blue';
+export declare class InternalContext implements ProcessingContext {
+    private getDocument;
+    private taskInfo;
+    private blue;
+    private onFlush?;
+    private readonly actions;
+    constructor(getDocument: () => DocumentNode, taskInfo: HandlerTask, blue: Blue, onFlush?: ((actions: ProcessingAction[]) => Promise<void>) | undefined);
+    get(path: string): string | boolean | import('..').BlueNode | import('..').BigIntegerNumber | import('..').BigDecimalNumber | null | undefined;
+    addPatch(patch: Patch): void;
+    emitEvent(event: EventNode): void;
+    flush(): Promise<ProcessingAction[]>;
+    getNodePath(): string;
+    resolvePath(path: string): string;
+    getTaskInfo(): HandlerTask | undefined;
+    getBlue(): Blue;
+    loadExternalModule(url: string): Promise<string>;
+    loadBlueContent(blueId: string): Promise<string>;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/lib/processor/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/lib/processor/context.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,KAAK,EACL,SAAS,EACT,gBAAgB,EAChB,WAAW,EACZ,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE/B,qBAAa,eAAgB,YAAW,iBAAiB;IAIrD,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,OAAO,CAAC;IANlB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;gBAGxC,WAAW,EAAE,MAAM,YAAY,EAC/B,QAAQ,EAAE,WAAW,EACrB,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,GAAE,CAAC,OAAO,EAAE,gBAAgB,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,aAAA;IAGlE,GAAG,CAAC,IAAI,EAAE,MAAM;IAMhB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAU5B,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAa3B,KAAK,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAQ1C,WAAW,IAAI,MAAM;IAIrB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAIjC,WAAW,IAAI,WAAW,GAAG,SAAS;IAItC,OAAO,IAAI,IAAI;IAMf,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAOhD,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAGjD"}

package/dist/lib/processor/processors/BaseChannelProcessor.d.ts

@@ -0,0 +1,27 @@
+import { ContractProcessor, EventNode, DocumentNode, ProcessingContext, BlueId } from '../types';
+export declare abstract class BaseChannelProcessor implements ContractProcessor {
+    abstract readonly contractType: string;
+    abstract readonly contractBlueId: BlueId;
+    readonly role = "adapter";
+    /**
+     * Base implementation of supports that checks if the event is not from a channel
+     * Derived classes should call this method first in their supports implementation
+     */
+    protected baseSupports(event: EventNode): boolean;
+    /**
+     * Abstract method that derived classes must implement
+     * Should contain specific logic for determining if the processor supports the event
+     */
+    abstract supports(event: EventNode, node: DocumentNode, ctx: ProcessingContext, contractName?: string): boolean;
+    /**
+     * Abstract method that derived classes must implement
+     * Should contain specific logic for handling the event
+     */
+    abstract handle(event: EventNode, node: DocumentNode, ctx: ProcessingContext, contractName?: string): void | Promise<void>;
+    /**
+     * Base implementation that returns empty array
+     * Can be overridden by derived classes if needed
+     */
+    init(): EventNode[];
+}
+//# sourceMappingURL=BaseChannelProcessor.d.ts.map

package/dist/lib/processor/processors/BaseChannelProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseChannelProcessor.d.ts","sourceRoot":"","sources":["../../../../src/lib/processor/processors/BaseChannelProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,SAAS,EACT,YAAY,EACZ,iBAAiB,EACjB,MAAM,EACP,MAAM,UAAU,CAAC;AAElB,8BAAsB,oBAAqB,YAAW,iBAAiB;IACrE,QAAQ,CAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IACzC,QAAQ,CAAC,IAAI,aAAa;IAE1B;;;OAGG;IACH,SAAS,CAAC,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO;IAKjD;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CACf,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,YAAY,EAClB,GAAG,EAAE,iBAAiB,EACtB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO;IAEV;;;OAGG;IACH,QAAQ,CAAC,MAAM,CACb,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,YAAY,EAClB,GAAG,EAAE,iBAAiB,EACtB,YAAY,CAAC,EAAE,MAAM,GACpB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAEvB;;;OAGG;IACH,IAAI,IAAI,SAAS,EAAE;CAGpB"}

package/dist/lib/processor/processors/ChannelEventCheckpointProcessor.d.ts

@@ -0,0 +1,13 @@
+import { ContractProcessor, DocumentNode, EventNode, ProcessingContext } from '../types';
+import { CheckpointCache } from '../utils/CheckpointCache';
+export declare class ChannelEventCheckpointProcessor implements ContractProcessor {
+    private readonly cache;
+    readonly contractType = "Channel Event Checkpoint";
+    readonly contractBlueId: "o27B7fuxMkKoutPh3uDxZ7dr6E5qxkQCS1VAptiCPc2R";
+    readonly role = "handler";
+    constructor(cache: CheckpointCache);
+    supports(evt: EventNode): boolean;
+    handle(event: EventNode, node: DocumentNode, ctx: ProcessingContext): Promise<void>;
+    init(): EventNode[];
+}
+//# sourceMappingURL=ChannelEventCheckpointProcessor.d.ts.map

package/dist/lib/processor/processors/ChannelEventCheckpointProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChannelEventCheckpointProcessor.d.ts","sourceRoot":"","sources":["../../../../src/lib/processor/processors/ChannelEventCheckpointProcessor.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,SAAS,EACT,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAO3D,qBAAa,+BAAgC,YAAW,iBAAiB;IAK3D,OAAO,CAAC,QAAQ,CAAC,KAAK;IAJlC,QAAQ,CAAC,YAAY,8BAA8B;IACnD,QAAQ,CAAC,cAAc,iDAAuC;IAC9D,QAAQ,CAAC,IAAI,aAAa;gBAEG,KAAK,EAAE,eAAe;IAEnD,QAAQ,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO;IAQ3B,MAAM,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,iBAAiB;IAYzE,IAAI,IAAI,SAAS,EAAE;CAGpB"}

package/dist/lib/processor/processors/CompositeTimelineChannelProcessor.d.ts

@@ -0,0 +1,9 @@
+import { EventNode, DocumentNode, ProcessingContext } from '../types';
+import { BaseChannelProcessor } from './BaseChannelProcessor';
+export declare class CompositeTimelineChannelProcessor extends BaseChannelProcessor {
+    readonly contractType = "Composite Timeline Channel";
+    readonly contractBlueId: "qxkh3uMkKoutP5DxZ7dr6Eo27B7fuxQCS1VAptiCPc2R";
+    supports(event: EventNode, node: DocumentNode, ctx: ProcessingContext): boolean;
+    handle(event: EventNode, node: DocumentNode, ctx: ProcessingContext, path: string): void;
+}
+//# sourceMappingURL=CompositeTimelineChannelProcessor.d.ts.map

package/dist/lib/processor/processors/CompositeTimelineChannelProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompositeTimelineChannelProcessor.d.ts","sourceRoot":"","sources":["../../../../src/lib/processor/processors/CompositeTimelineChannelProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAI9D,qBAAa,iCAAkC,SAAQ,oBAAoB;IACzE,QAAQ,CAAC,YAAY,gCAAgC;IACrD,QAAQ,CAAC,cAAc,iDAAyC;IAEhE,QAAQ,CACN,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,YAAY,EAClB,GAAG,EAAE,iBAAiB,GACrB,OAAO;IAWV,MAAM,CACJ,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,YAAY,EAClB,GAAG,EAAE,iBAAiB,EACtB,IAAI,EAAE,MAAM,GACX,IAAI;CAOR"}

package/dist/lib/processor/processors/DocumentUpdateChannelProcessor.d.ts

@@ -0,0 +1,9 @@
+import { EventNode, DocumentNode, ProcessingContext } from '../types';
+import { BaseChannelProcessor } from './BaseChannelProcessor';
+export declare class DocumentUpdateChannelProcessor extends BaseChannelProcessor {
+    readonly contractType = "Document Update Channel";
+    readonly contractBlueId: "MkKoutP5qxkh3uDQCS1VAptiCPc2xZ7dr6Eo27B7fux";
+    supports(event: EventNode, contractNode: DocumentNode, ctx: ProcessingContext, contractName: string): boolean;
+    handle(event: EventNode, contractNode: DocumentNode, ctx: ProcessingContext, contractName: string): void;
+}
+//# sourceMappingURL=DocumentUpdateChannelProcessor.d.ts.map