import { ModelStatus } from '../../../catalog/domain/enum/model-status.enum';
import { ErrorCode } from '../../../model/domain/enum/error-code.enum';
/**
 * Base interface for all Model domain events
 */
export interface ModelDomainEvent {
    readonly eventType: string;
    readonly aggregateId: string;
    readonly occurredOn: Date;
    readonly version: number;
    readonly payload: Record<string, unknown>;
}
/**
 * Model has been discovered in storage
 */
export interface ModelDiscoveredPayload {
    readonly modelId: string;
    readonly ownerId: string;
    readonly libraryId: string;
    readonly fileName: string;
    readonly [key: string]: unknown;
}
export declare class ModelDiscovered implements ModelDomainEvent {
    readonly aggregateId: string;
    readonly payload: ModelDiscoveredPayload;
    readonly eventType = "ModelDiscovered";
    readonly occurredOn: Date;
    readonly version = 1;
    constructor(aggregateId: string, payload: ModelDiscoveredPayload, occurredOn?: Date);
    static create(aggregateId: string, payload: ModelDiscoveredPayload): ModelDiscovered;
    toJSON(): Record<string, unknown>;
    static fromJSON(data: Record<string, unknown>): ModelDiscovered;
}
/**
 * Model has been successfully processed
 */
export interface ModelProcessedPayload {
    readonly modelId: string;
    readonly status: ModelStatus;
    readonly [key: string]: unknown;
}
export declare class ModelProcessed implements ModelDomainEvent {
    readonly aggregateId: string;
    readonly payload: ModelProcessedPayload;
    readonly eventType = "ModelProcessed";
    readonly occurredOn: Date;
    readonly version = 1;
    constructor(aggregateId: string, payload: ModelProcessedPayload, occurredOn?: Date);
    static create(aggregateId: string, payload: ModelProcessedPayload): ModelProcessed;
    toJSON(): Record<string, unknown>;
    static fromJSON(data: Record<string, unknown>): ModelProcessed;
}
/**
 * An error occurred during model processing
 */
export interface ModelErrorOccurredPayload {
    readonly modelId: string;
    readonly errorCode: ErrorCode;
    readonly errorMessage: string;
    readonly [key: string]: unknown;
}
export declare class ModelErrorOccurred implements ModelDomainEvent {
    readonly aggregateId: string;
    readonly payload: ModelErrorOccurredPayload;
    readonly eventType = "ModelErrorOccurred";
    readonly occurredOn: Date;
    readonly version = 1;
    constructor(aggregateId: string, payload: ModelErrorOccurredPayload, occurredOn?: Date);
    static create(aggregateId: string, payload: ModelErrorOccurredPayload): ModelErrorOccurred;
    toJSON(): Record<string, unknown>;
    static fromJSON(data: Record<string, unknown>): ModelErrorOccurred;
}
/**
 * Model status has changed
 */
export interface ModelStatusChangedPayload {
    readonly modelId: string;
    readonly oldStatus: ModelStatus;
    readonly newStatus: ModelStatus;
    readonly [key: string]: unknown;
}
export declare class ModelStatusChanged implements ModelDomainEvent {
    readonly aggregateId: string;
    readonly payload: ModelStatusChangedPayload;
    readonly eventType = "ModelStatusChanged";
    readonly occurredOn: Date;
    readonly version = 1;
    constructor(aggregateId: string, payload: ModelStatusChangedPayload, occurredOn?: Date);
    static create(aggregateId: string, payload: ModelStatusChangedPayload): ModelStatusChanged;
    toJSON(): Record<string, unknown>;
    static fromJSON(data: Record<string, unknown>): ModelStatusChanged;
}
/**
 * Union type of all Model events
 */
export type ModelEvent = ModelDiscovered | ModelProcessed | ModelErrorOccurred | ModelStatusChanged;
/**
 * Event type discriminator
 */
export declare const ModelEventTypes: {
    readonly ModelDiscovered: "ModelDiscovered";
    readonly ModelProcessed: "ModelProcessed";
    readonly ModelErrorOccurred: "ModelErrorOccurred";
    readonly ModelStatusChanged: "ModelStatusChanged";
};
/**
 * Event registry for polymorphic deserialization
 */
export declare const MODEL_EVENT_REGISTRY: Record<string, {
    fromJSON: (data: Record<string, unknown>) => ModelDomainEvent;
}>;
/**
 * Deserialize any Model event from JSON using eventType discriminator
 * @param data - Object containing event data with 'eventType' key
 * @returns The deserialized event instance
 * @throws Error if eventType is unknown
 */
export declare function deserializeModelEvent(data: Record<string, unknown>): ModelDomainEvent;
//# sourceMappingURL=model.events.d.ts.map