@magek/core 0.0.1

package/dist/decorators/field-metadata-reader.js

@@ -0,0 +1,221 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildClassMetadataFromFields = buildClassMetadataFromFields;
+require("reflect-metadata");
+// Symbol used by Stage 3 decorators to store field metadata
+const FIELDS_KEY = Symbol.for('magek:fields');
+// Symbol.metadata may not be defined in all TypeScript lib versions
+// Use a well-known symbol that Stage 3 decorators use
+const METADATA_KEY = (_a = Symbol.metadata) !== null && _a !== void 0 ? _a : Symbol.for('Symbol.metadata');
+/**
+ * Extract TypeMetadata from a @Field() decorator's metadata
+ */
+function extractTypeMetadata(fieldMeta, isGetter = false) {
+    let targetType;
+    let isArray = false;
+    let isReadonlyArray = false;
+    // If typeFunction is provided, use it
+    if (fieldMeta.typeFunction) {
+        const result = fieldMeta.typeFunction();
+        // Handle array syntax: @Field(type => [String])
+        if (Array.isArray(result)) {
+            isArray = true;
+            targetType = result[0];
+        }
+        else {
+            targetType = result;
+        }
+    }
+    else {
+        // Fall back to design:type from emitDecoratorMetadata
+        targetType = fieldMeta.designType;
+    }
+    // Determine type group and construct TypeMetadata
+    return analyzeType(targetType, {
+        isNullable: fieldMeta.options.nullable || false,
+        isGetAccessor: isGetter,
+        isArray,
+        isReadonlyArray,
+    });
+}
+/**
+ * Analyze a type and convert it to TypeMetadata
+ */
+function analyzeType(targetType, options) {
+    const { isNullable, isGetAccessor, isArray, isReadonlyArray } = options;
+    // Handle Array first (before primitive checks, since element type may be a primitive)
+    if (isArray || isReadonlyArray) {
+        const elementType = analyzeType(targetType, {
+            isNullable: false,
+            isGetAccessor: false,
+            isArray: false,
+            isReadonlyArray: false,
+        });
+        return {
+            name: isReadonlyArray ? `readonly ${elementType.name}[]` : `${elementType.name}[]`,
+            typeGroup: isReadonlyArray ? 'ReadonlyArray' : 'Array',
+            typeName: isReadonlyArray ? 'ReadonlyArray' : 'Array',
+            parameters: [elementType],
+            isNullable,
+            isGetAccessor,
+        };
+    }
+    // Handle primitives
+    if (targetType === String) {
+        return {
+            name: 'string',
+            typeGroup: 'String',
+            typeName: 'String',
+            parameters: [],
+            isNullable,
+            isGetAccessor,
+            type: String,
+        };
+    }
+    if (targetType === Number) {
+        return {
+            name: 'number',
+            typeGroup: 'Number',
+            typeName: 'Number',
+            parameters: [],
+            isNullable,
+            isGetAccessor,
+            type: Number,
+        };
+    }
+    if (targetType === Boolean) {
+        return {
+            name: 'boolean',
+            typeGroup: 'Boolean',
+            typeName: 'Boolean',
+            parameters: [],
+            isNullable,
+            isGetAccessor,
+            type: Boolean,
+        };
+    }
+    // Handle Object (fallback for unknown types)
+    if (targetType === Object || !targetType) {
+        return {
+            name: 'any',
+            typeGroup: 'Other',
+            typeName: 'any',
+            parameters: [],
+            isNullable,
+            isGetAccessor,
+        };
+    }
+    // Handle Class types
+    if (typeof targetType === 'function') {
+        return {
+            name: targetType.name || 'Unknown',
+            typeGroup: 'Class',
+            typeName: targetType.name,
+            parameters: [],
+            isNullable,
+            isGetAccessor,
+            type: targetType,
+        };
+    }
+    // Default fallback
+    return {
+        name: 'unknown',
+        typeGroup: 'Other',
+        typeName: 'unknown',
+        parameters: [],
+        isNullable,
+        isGetAccessor,
+    };
+}
+/**
+ * Get all fields from a class, including inherited fields
+ */
+function getAllFields(classType) {
+    const fields = [];
+    // First, check for Stage 3 decorator metadata (Symbol.metadata on the class)
+    // Stage 3 decorators store metadata in classType[Symbol.metadata]
+    const classAsRecord = classType;
+    const metadata = classAsRecord[METADATA_KEY];
+    if (metadata && metadata[FIELDS_KEY]) {
+        const stage3Fields = metadata[FIELDS_KEY];
+        for (const field of stage3Fields) {
+            if (!fields.some((f) => f.name === field.name)) {
+                fields.push(field);
+            }
+        }
+    }
+    // Then walk up the prototype chain for legacy decorator metadata
+    let currentPrototype = classType.prototype;
+    while (currentPrototype && currentPrototype !== Object.prototype) {
+        const constructor = currentPrototype.constructor;
+        // Try Reflect.getMetadata first, then fallback to __magek_fields__
+        let prototypeFields = [];
+        if (typeof Reflect.getMetadata === 'function') {
+            prototypeFields = Reflect.getMetadata('magek:fields', constructor) || [];
+        }
+        // Also check fallback property
+        if (prototypeFields.length === 0 && constructor.__magek_fields__) {
+            prototypeFields = constructor.__magek_fields__;
+        }
+        // Add fields that aren't already in the list (child overrides parent)
+        for (const field of prototypeFields) {
+            if (!fields.some((f) => f.name === field.name)) {
+                fields.push(field);
+            }
+        }
+        currentPrototype = Object.getPrototypeOf(currentPrototype);
+    }
+    return fields;
+}
+/**
+ * Get all getters (calculated fields) from a class
+ */
+function getAllGetters(classType) {
+    var _a;
+    const getters = [];
+    const prototype = classType.prototype;
+    // Get property descriptors
+    const descriptors = Object.getOwnPropertyDescriptors(prototype);
+    for (const [propertyKey, descriptor] of Object.entries(descriptors)) {
+        if (descriptor.get) {
+            // This is a getter, check if it has @CalculatedField metadata
+            const dependencies = ((_a = Reflect.getMetadata('dynamic:dependencies', classType)) === null || _a === void 0 ? void 0 : _a[propertyKey]) || [];
+            // Get return type from design:returntype if available
+            const returnType = Reflect.getMetadata('design:returntype', prototype, propertyKey);
+            const typeMetadata = analyzeType(returnType || Object, {
+                isNullable: false,
+                isGetAccessor: true,
+                isArray: false,
+                isReadonlyArray: false,
+            });
+            getters.push({
+                name: propertyKey,
+                typeInfo: typeMetadata,
+                dependencies,
+            });
+        }
+    }
+    return getters;
+}
+/**
+ * Build ClassMetadata from @Field() decorators
+ */
+function buildClassMetadataFromFields(classType) {
+    // Get all fields (including inherited)
+    const fieldMetadatas = getAllFields(classType);
+    // Convert to PropertyMetadata
+    const fields = fieldMetadatas.map((fieldMeta) => ({
+        name: fieldMeta.name,
+        typeInfo: extractTypeMetadata(fieldMeta, false),
+        dependencies: [],
+    }));
+    // Get getter methods (for @CalculatedField)
+    const methods = getAllGetters(classType);
+    return {
+        name: classType.name,
+        type: classType,
+        fields,
+        methods,
+    };
+}

package/dist/decorators/global-error-handler.d.ts

@@ -0,0 +1,2 @@
+import { GlobalErrorHandlerInterface } from '@magek/common';
+export declare function GlobalErrorHandler(): (errorHandlerClass: GlobalErrorHandlerInterface) => void;

package/dist/decorators/global-error-handler.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalErrorHandler = GlobalErrorHandler;
+const magek_1 = require("../magek");
+function GlobalErrorHandler() {
+    return (errorHandlerClass) => {
+        magek_1.Magek.configureCurrentEnv((config) => {
+            if (config.globalErrorsHandler) {
+                throw new Error(`An error handler called ${errorHandlerClass.name} is already registered.
+        If you think that this is an error, try performing a clean build.`);
+            }
+            config.globalErrorsHandler = { class: errorHandlerClass };
+        });
+    };
+}

package/dist/decorators/global-event-handler.d.ts

@@ -0,0 +1,3 @@
+import { EventHandlerInterface } from '@magek/common';
+export declare const GLOBAL_EVENT_HANDLERS = "GLOBAL_EVENT_HANDLERS";
+export declare function GlobalEventHandler<TEventHandler extends EventHandlerInterface>(eventHandlerClass: TEventHandler): void;

package/dist/decorators/global-event-handler.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLOBAL_EVENT_HANDLERS = void 0;
+exports.GlobalEventHandler = GlobalEventHandler;
+const event_handler_1 = require("./event-handler");
+exports.GLOBAL_EVENT_HANDLERS = 'GLOBAL_EVENT_HANDLERS';
+function GlobalEventHandler(eventHandlerClass) {
+    (0, event_handler_1.registerEventHandler)(exports.GLOBAL_EVENT_HANDLERS, eventHandlerClass);
+}

package/dist/decorators/health-sensor.d.ts

@@ -0,0 +1,14 @@
+import { Class, HealthIndicatorConfiguration, HealthIndicatorInterface } from '@magek/common';
+/**
+ * Decorator to mark a class as a Magek Health Sensor.
+ * Health sensors provide health status information for monitoring endpoints.
+ *
+ * @param attributes - Health indicator configuration
+ * @param attributes.id - Unique indicator identifier
+ * @param attributes.name - Indicator description
+ * @param attributes.enabled - If false, this indicator and its children will be skipped
+ * @param attributes.details - If false, the indicator will not include details
+ * @param attributes.showChildren - If false, children components won't be included in the tree
+ * @returns A class decorator function
+ */
+export declare function HealthSensor(attributes: HealthIndicatorConfiguration): <TIndicator extends HealthIndicatorInterface>(healthIndicator: Class<TIndicator>) => void;

package/dist/decorators/health-sensor.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthSensor = HealthSensor;
+const magek_1 = require("../magek");
+const health_indicators_1 = require("../sensor/health/health-indicators");
+/**
+ * Decorator to mark a class as a Magek Health Sensor.
+ * Health sensors provide health status information for monitoring endpoints.
+ *
+ * @param attributes - Health indicator configuration
+ * @param attributes.id - Unique indicator identifier
+ * @param attributes.name - Indicator description
+ * @param attributes.enabled - If false, this indicator and its children will be skipped
+ * @param attributes.details - If false, the indicator will not include details
+ * @param attributes.showChildren - If false, children components won't be included in the tree
+ * @returns A class decorator function
+ */
+function HealthSensor(attributes) {
+    return (healthIndicator) => {
+        magek_1.Magek.configureCurrentEnv((config) => {
+            var _a;
+            if (Object.keys(config.userHealthIndicators).length === 0) {
+                config.userHealthIndicators = (0, health_indicators_1.defaultMagekHealthIndicators)(config);
+            }
+            const path = attributes.id;
+            config.userHealthIndicators[path] = {
+                class: healthIndicator,
+                healthIndicatorConfiguration: {
+                    id: attributes.id,
+                    name: attributes.name,
+                    enabled: attributes.enabled,
+                    details: attributes.details,
+                    showChildren: (_a = attributes.showChildren) !== null && _a !== void 0 ? _a : true,
+                },
+            };
+        });
+    };
+}

package/dist/decorators/index.d.ts

@@ -0,0 +1,16 @@
+export * from './command';
+export * from './query';
+export * from './data-migration';
+export * from './entity';
+export * from './event';
+export * from './event-handler';
+export * from './global-error-handler';
+export * from './notification';
+export * from './projects';
+export * from './read-model';
+export * from './role';
+export * from './scheduled-command';
+export * from './schema-migration';
+export * from './sequenced-by';
+export * from './global-event-handler';
+export * from './non-exposed';

package/dist/decorators/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./command"), exports);
+tslib_1.__exportStar(require("./query"), exports);
+tslib_1.__exportStar(require("./data-migration"), exports);
+tslib_1.__exportStar(require("./entity"), exports);
+tslib_1.__exportStar(require("./event"), exports);
+tslib_1.__exportStar(require("./event-handler"), exports);
+tslib_1.__exportStar(require("./global-error-handler"), exports);
+tslib_1.__exportStar(require("./notification"), exports);
+tslib_1.__exportStar(require("./projects"), exports);
+tslib_1.__exportStar(require("./read-model"), exports);
+tslib_1.__exportStar(require("./role"), exports);
+tslib_1.__exportStar(require("./scheduled-command"), exports);
+tslib_1.__exportStar(require("./schema-migration"), exports);
+tslib_1.__exportStar(require("./sequenced-by"), exports);
+tslib_1.__exportStar(require("./global-event-handler"), exports);
+tslib_1.__exportStar(require("./non-exposed"), exports);

package/dist/decorators/metadata.d.ts

@@ -0,0 +1,13 @@
+import { AnyClass, ClassMetadata } from '@magek/common';
+export declare function getClassMetadata(classType: AnyClass): ClassMetadata;
+/**
+ * Get the argument names from a given function.
+ *
+ * This implementation is a TypeScript adaptation of a JavaScript implementation
+ * borrowed from the promisify-node code and can be found in the following link:
+ * https://github.com/nodegit/promisify-node/blob/02fc47cfc00146a533193bc4740e2e3e3be81c6f/utils/args.js
+ *
+ * @param {Function} func - The function to parse.
+ * @returns {Array} arg - List of arguments in the function.
+ */
+export declare function getFunctionArguments(func: Function): Array<string>;

package/dist/decorators/metadata.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClassMetadata = getClassMetadata;
+exports.getFunctionArguments = getFunctionArguments;
+const common_1 = require("@magek/common");
+const field_metadata_reader_1 = require("./field-metadata-reader");
+function getClassMetadata(classType) {
+    // Try new @Field() decorator system first
+    try {
+        const fieldMetadata = (0, field_metadata_reader_1.buildClassMetadataFromFields)(classType);
+        // Check if any fields were actually found
+        if (fieldMetadata.fields.length > 0 || fieldMetadata.methods.length > 0) {
+            return fieldMetadata;
+        }
+    }
+    catch (error) {
+        // If field metadata reading fails, try old system
+    }
+    // Fall back to old transformer-based system
+    const meta = (0, common_1.getMetadata)('magek:typeinfo', classType);
+    if (!meta) {
+        throw Error(`Couldn't get proper metadata information of ${classType.name}. ` +
+            'Make sure to decorate all properties with @Field() or enable the TypeScript transformer.');
+    }
+    return meta;
+}
+/**
+ * Get the argument names from a given function.
+ *
+ * This implementation is a TypeScript adaptation of a JavaScript implementation
+ * borrowed from the promisify-node code and can be found in the following link:
+ * https://github.com/nodegit/promisify-node/blob/02fc47cfc00146a533193bc4740e2e3e3be81c6f/utils/args.js
+ *
+ * @param {Function} func - The function to parse.
+ * @returns {Array} arg - List of arguments in the function.
+ */
+// TODO: Consider extending `@magek/metadata` to yield constructor argument types
+function getFunctionArguments(func) {
+    var _a;
+    // First match everything inside the function argument parens.
+    const args = (_a = func.toString().match(/([^(])*\(([^)]*)\)/)) === null || _a === void 0 ? void 0 : _a[2];
+    if (!args)
+        return [];
+    // Split the arguments string into an array comma delimited.
+    return args
+        .split(', ')
+        .map(function (arg) {
+        // Ensure no inline comments are parsed and trim the whitespace.
+        return arg.replace(/\/\*.*\*\//, '').trim();
+    })
+        .filter(function (arg) {
+        // Ensure no undefineds are added.
+        return arg;
+    });
+}

package/dist/decorators/non-exposed.d.ts

@@ -0,0 +1,2 @@
+import { AnyClass } from '@magek/common';
+export declare function NonExposed(target: AnyClass | InstanceType<AnyClass>, methodName: string | undefined, parameterIndex?: number): void;

package/dist/decorators/non-exposed.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonExposed = NonExposed;
+const magek_1 = require("../magek");
+const metadata_1 = require("./metadata");
+function NonExposed(target, methodName, parameterIndex) {
+    magek_1.Magek.configureCurrentEnv((config) => {
+        var _a;
+        const className = (_a = target.name) !== null && _a !== void 0 ? _a : target.constructor.name;
+        const value = config.nonExposedGraphQLMetadataKey[className] || [];
+        const fieldName = getFieldName(methodName, target, parameterIndex);
+        config.nonExposedGraphQLMetadataKey[className] = [...value, fieldName];
+    });
+}
+function getFieldName(methodName, target, parameterIndex) {
+    if (methodName) {
+        return methodName;
+    }
+    if (!parameterIndex) {
+        throw new Error(`We could not get field name information in ${target} for method ${methodName}`);
+    }
+    const argumentNames = (0, metadata_1.getFunctionArguments)(target);
+    return argumentNames[parameterIndex];
+}

package/dist/decorators/notification.d.ts

@@ -0,0 +1,35 @@
+import { Class, NotificationInterface } from '@magek/common';
+export type NotificationOptions = {
+    topic?: string;
+};
+/**
+ * Stage 3 field decorator context
+ */
+interface Stage3FieldContext {
+    kind: 'field';
+    name: string | symbol;
+    static: boolean;
+    private: boolean;
+    metadata: Record<string | symbol, unknown>;
+    addInitializer?: (initializer: () => void) => void;
+}
+/**
+ * Decorator to mark a class as a Magek Notification.
+ * Notifications are events that can be published to external systems.
+ *
+ * @param options - Optional configuration for the notification (e.g., topic name)
+ * @returns A class decorator function
+ */
+export declare const Notification: <TEvent extends NotificationInterface>(options?: NotificationOptions) => (eventClass: Class<TEvent>, context?: {
+    kind: "class";
+    metadata: Record<string | symbol, unknown>;
+}) => void;
+/**
+ * Optional decorator that marks a field in a notification class as the partition key.
+ * This is useful if you want to guarantee that all the event handlers for notifications
+ * of the same type will be executed in the same order.
+ *
+ * Can be used as both a parameter decorator and property decorator.
+ */
+export declare function partitionKey(target: Class<NotificationInterface> | Object | undefined, propertyKeyOrContext?: string | symbol | Stage3FieldContext, parameterIndex?: number): void;
+export {};

package/dist/decorators/notification.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Notification = void 0;
+exports.partitionKey = partitionKey;
+const magek_1 = require("../magek");
+const metadata_1 = require("./metadata");
+/**
+ * Type guard to detect Stage 3 field decorator context
+ */
+function isStage3FieldContext(arg) {
+    return (arg !== null &&
+        typeof arg === 'object' &&
+        'kind' in arg &&
+        arg.kind === 'field' &&
+        'name' in arg);
+}
+// Symbol for storing partition key in Stage 3 metadata
+const PARTITION_KEY_SYMBOL = Symbol.for('magek:partitionKey');
+/**
+ * Decorator to mark a class as a Magek Notification.
+ * Notifications are events that can be published to external systems.
+ *
+ * @param options - Optional configuration for the notification (e.g., topic name)
+ * @returns A class decorator function
+ */
+const Notification = (options) => (eventClass, context) => {
+    // Handle Stage 3: transfer partition key from context.metadata to config
+    if (context && context.kind === 'class' && context.metadata[PARTITION_KEY_SYMBOL]) {
+        const propertyName = context.metadata[PARTITION_KEY_SYMBOL];
+        magek_1.Magek.configureCurrentEnv((config) => {
+            config.partitionKeys[eventClass.name] = propertyName;
+        });
+    }
+    magek_1.Magek.configureCurrentEnv((config) => {
+        var _a;
+        if (config.notifications[eventClass.name] || config.events[eventClass.name]) {
+            throw new Error(`A notification called ${eventClass.name} is already registered.
+        If you think that this is an error, try performing a clean build.`);
+        }
+        const topic = (_a = options === null || options === void 0 ? void 0 : options.topic) !== null && _a !== void 0 ? _a : 'defaultTopic';
+        if (topic) {
+            config.eventToTopic[eventClass.name] = topic;
+            config.topicToEvent[topic] = eventClass.name;
+        }
+        config.notifications[eventClass.name] = {
+            class: eventClass,
+        };
+    });
+};
+exports.Notification = Notification;
+/**
+ * Optional decorator that marks a field in a notification class as the partition key.
+ * This is useful if you want to guarantee that all the event handlers for notifications
+ * of the same type will be executed in the same order.
+ *
+ * Can be used as both a parameter decorator and property decorator.
+ */
+function partitionKey(target, propertyKeyOrContext, parameterIndex) {
+    // Stage 3 field decorator usage
+    if (isStage3FieldContext(propertyKeyOrContext)) {
+        const context = propertyKeyOrContext;
+        const propertyName = String(context.name);
+        // Store in context.metadata so @Notification can read it
+        context.metadata[PARTITION_KEY_SYMBOL] = propertyName;
+        return;
+    }
+    // Property decorator usage: @partitionKey on a class property (legacy)
+    if (propertyKeyOrContext !== undefined && parameterIndex === undefined && target) {
+        const notificationClass = target.constructor;
+        const propertyName = String(propertyKeyOrContext);
+        magek_1.Magek.configureCurrentEnv((config) => {
+            if (config.partitionKeys[notificationClass.name] && config.partitionKeys[notificationClass.name] !== propertyName) {
+                throw new Error(`Error trying to register a partition key named \`${propertyName}\` for class \`${notificationClass.name}\`. It already had the partition key \`${config.partitionKeys[notificationClass.name]}\` defined and only one partition key is allowed for each notification event.`);
+            }
+            else {
+                config.partitionKeys[notificationClass.name] = propertyName;
+            }
+        });
+    }
+    // Parameter decorator usage: @partitionKey on constructor parameter
+    else if (parameterIndex !== undefined && target) {
+        const notificationClass = target;
+        const args = (0, metadata_1.getFunctionArguments)(notificationClass);
+        const propertyName = args[parameterIndex];
+        magek_1.Magek.configureCurrentEnv((config) => {
+            if (config.partitionKeys[notificationClass.name] && config.partitionKeys[notificationClass.name] !== propertyName) {
+                throw new Error(`Error trying to register a partition key named \`${propertyName}\` for class \`${notificationClass.name}\`. It already had the partition key \`${config.partitionKeys[notificationClass.name]}\` defined and only one partition key is allowed for each notification event.`);
+            }
+            else {
+                config.partitionKeys[notificationClass.name] = propertyName;
+            }
+        });
+    }
+}

package/dist/decorators/projects.d.ts

@@ -0,0 +1,32 @@
+import { Class, EntityInterface, ProjectionInfo, ProjectionResult, ReadModelInterface, ReadModelJoinKeyFunction, UUID } from '@magek/common';
+type PropertyType<TObj, TProp extends keyof TObj> = TObj[TProp];
+type JoinKeyType<TEntity extends EntityInterface, TReadModel extends ReadModelInterface> = keyof TEntity | ReadModelJoinKeyFunction<TEntity, TReadModel>;
+type UUIDLike = string | UUID;
+/**
+ * Stage 3 method decorator context
+ */
+interface Stage3MethodContext {
+    kind: 'method';
+    name: string | symbol;
+    static: boolean;
+    private: boolean;
+    metadata: Record<string | symbol, unknown>;
+    addInitializer?: (initializer: () => void) => void;
+}
+/**
+ * Decorator to register a read model method as a projection
+ * for a specific entity
+ *
+ * @param originEntity The entity that this method will react to
+ * @param joinKey
+ * @param unProject
+ */
+export declare function Projects<TEntity extends EntityInterface, TJoinKey extends keyof TEntity, TReadModel extends ReadModelInterface>(originEntity: Class<TEntity>, joinKey: JoinKeyType<TEntity, TReadModel>, unProject?: UnprojectionMethod<TEntity, TReadModel, PropertyType<TEntity, TJoinKey>>): <TReceivedReadModel extends ReadModelInterface>(readModelClassOrMethod: Class<TReceivedReadModel> | Function, methodNameOrContext: string | Stage3MethodContext, methodDescriptor?: ProjectionMethod<TEntity, TReceivedReadModel, JoinKeyType<TEntity, TReceivedReadModel>>) => void;
+type ProjectionMethodDefinitionForArray<TEntity, TReadModel> = (_: TEntity, readModelID: UUID, readModel?: TReadModel, projectionInfo?: ProjectionInfo) => ProjectionResult<TReadModel>;
+type ProjectionMethodDefinition<TEntity, TReadModel> = (_: TEntity, readModel?: TReadModel, projectionInfo?: ProjectionInfo) => ProjectionResult<TReadModel>;
+type ProjectionMethod<TEntity extends EntityInterface, TReadModel extends ReadModelInterface, TJoinKeyType extends JoinKeyType<TEntity, TReadModel>> = TJoinKeyType extends ReadModelJoinKeyFunction<TEntity, TReadModel> ? ProjectionMethodWithEntityConditionalReadModelIdAndReadModel<TEntity, TReadModel> : TJoinKeyType extends keyof TEntity ? NonNullable<PropertyType<TEntity, TJoinKeyType>> extends Array<UUIDLike> ? ProjectionMethodWithEntityReadModelIdAndReadModel<TEntity, TReadModel> : ProjectionMethodWithEntityAndReadModel<TEntity, TReadModel> : never;
+type ProjectionMethodWithEntityAndReadModel<TEntity extends EntityInterface, TReadModel extends ReadModelInterface> = TypedPropertyDescriptor<(_: TEntity, readModel?: TReadModel) => ProjectionResult<TReadModel>>;
+type ProjectionMethodWithEntityConditionalReadModelIdAndReadModel<TEntity extends EntityInterface, TReadModel extends ReadModelInterface> = TypedPropertyDescriptor<(_: TEntity, readModelID: UUID | undefined, readModel?: TReadModel) => ProjectionResult<TReadModel>>;
+type ProjectionMethodWithEntityReadModelIdAndReadModel<TEntity extends EntityInterface, TReadModel extends ReadModelInterface> = TypedPropertyDescriptor<(_: TEntity, readModelID: UUID, readModel?: TReadModel) => ProjectionResult<TReadModel>>;
+type UnprojectionMethod<TEntity, TReadModel, TPropType> = TPropType extends Array<UUID> ? ProjectionMethodDefinitionForArray<TEntity, TReadModel> : ProjectionMethodDefinition<TEntity, TReadModel>;
+export {};