@valentine-efagene/qshelter-common 2.0.66 → 2.0.68

package/dist/generated/client/internal/prismaNamespace.d.ts

@@ -277,6 +277,11 @@ export declare const ModelName: {
     readonly ContractTermination: "ContractTermination";
     readonly PaymentMethodChangeRequest: "PaymentMethodChangeRequest";
     readonly DocumentRequirementRule: "DocumentRequirementRule";
+    readonly EventChannel: "EventChannel";
+    readonly EventType: "EventType";
+    readonly EventHandler: "EventHandler";
+    readonly WorkflowEvent: "WorkflowEvent";
+    readonly EventHandlerExecution: "EventHandlerExecution";
     readonly DomainEvent: "DomainEvent";
 };
 export type ModelName = (typeof ModelName)[keyof typeof ModelName];
@@ -290,7 +295,7 @@ export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runt
         omit: GlobalOmitOptions;
     };
     meta: {
-        modelProps: "user" | "role" | "permission" | "rolePermission" | "userRole" | "tenant" | "apiKey" | "refreshToken" | "passwordReset" | "userSuspension" | "emailPreference" | "deviceEndpoint" | "social" | "oAuthState" | "wallet" | "transaction" | "settings" | "property" | "propertyMedia" | "propertyDocument" | "amenity" | "propertyVariant" | "propertyVariantAmenity" | "propertyVariantMedia" | "propertyUnit" | "propertyAmenity" | "paymentPlan" | "propertyPaymentMethod" | "propertyPaymentMethodLink" | "propertyPaymentMethodPhase" | "paymentMethodPhaseStep" | "paymentMethodPhaseDocument" | "contract" | "contractPhase" | "documentationStep" | "documentationStepDocument" | "documentationStepApproval" | "contractInstallment" | "contractPayment" | "contractDocument" | "contractEvent" | "documentTemplate" | "offerLetter" | "contractTermination" | "paymentMethodChangeRequest" | "documentRequirementRule" | "domainEvent";
+        modelProps: "user" | "role" | "permission" | "rolePermission" | "userRole" | "tenant" | "apiKey" | "refreshToken" | "passwordReset" | "userSuspension" | "emailPreference" | "deviceEndpoint" | "social" | "oAuthState" | "wallet" | "transaction" | "settings" | "property" | "propertyMedia" | "propertyDocument" | "amenity" | "propertyVariant" | "propertyVariantAmenity" | "propertyVariantMedia" | "propertyUnit" | "propertyAmenity" | "paymentPlan" | "propertyPaymentMethod" | "propertyPaymentMethodLink" | "propertyPaymentMethodPhase" | "paymentMethodPhaseStep" | "paymentMethodPhaseDocument" | "contract" | "contractPhase" | "documentationStep" | "documentationStepDocument" | "documentationStepApproval" | "contractInstallment" | "contractPayment" | "contractDocument" | "contractEvent" | "documentTemplate" | "offerLetter" | "contractTermination" | "paymentMethodChangeRequest" | "documentRequirementRule" | "eventChannel" | "eventType" | "eventHandler" | "workflowEvent" | "eventHandlerExecution" | "domainEvent";
         txIsolationLevel: TransactionIsolationLevel;
     };
     model: {
@@ -3330,6 +3335,336 @@ export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runt
                 };
             };
         };
+        EventChannel: {
+            payload: Prisma.$EventChannelPayload<ExtArgs>;
+            fields: Prisma.EventChannelFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.EventChannelFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventChannelPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.EventChannelFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventChannelPayload>;
+                };
+                findFirst: {
+                    args: Prisma.EventChannelFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventChannelPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.EventChannelFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventChannelPayload>;
+                };
+                findMany: {
+                    args: Prisma.EventChannelFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventChannelPayload>[];
+                };
+                create: {
+                    args: Prisma.EventChannelCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventChannelPayload>;
+                };
+                createMany: {
+                    args: Prisma.EventChannelCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                delete: {
+                    args: Prisma.EventChannelDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventChannelPayload>;
+                };
+                update: {
+                    args: Prisma.EventChannelUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventChannelPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.EventChannelDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.EventChannelUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                upsert: {
+                    args: Prisma.EventChannelUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventChannelPayload>;
+                };
+                aggregate: {
+                    args: Prisma.EventChannelAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateEventChannel>;
+                };
+                groupBy: {
+                    args: Prisma.EventChannelGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.EventChannelGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.EventChannelCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.EventChannelCountAggregateOutputType> | number;
+                };
+            };
+        };
+        EventType: {
+            payload: Prisma.$EventTypePayload<ExtArgs>;
+            fields: Prisma.EventTypeFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.EventTypeFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventTypePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.EventTypeFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventTypePayload>;
+                };
+                findFirst: {
+                    args: Prisma.EventTypeFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventTypePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.EventTypeFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventTypePayload>;
+                };
+                findMany: {
+                    args: Prisma.EventTypeFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventTypePayload>[];
+                };
+                create: {
+                    args: Prisma.EventTypeCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventTypePayload>;
+                };
+                createMany: {
+                    args: Prisma.EventTypeCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                delete: {
+                    args: Prisma.EventTypeDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventTypePayload>;
+                };
+                update: {
+                    args: Prisma.EventTypeUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventTypePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.EventTypeDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.EventTypeUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                upsert: {
+                    args: Prisma.EventTypeUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventTypePayload>;
+                };
+                aggregate: {
+                    args: Prisma.EventTypeAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateEventType>;
+                };
+                groupBy: {
+                    args: Prisma.EventTypeGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.EventTypeGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.EventTypeCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.EventTypeCountAggregateOutputType> | number;
+                };
+            };
+        };
+        EventHandler: {
+            payload: Prisma.$EventHandlerPayload<ExtArgs>;
+            fields: Prisma.EventHandlerFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.EventHandlerFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.EventHandlerFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerPayload>;
+                };
+                findFirst: {
+                    args: Prisma.EventHandlerFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.EventHandlerFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerPayload>;
+                };
+                findMany: {
+                    args: Prisma.EventHandlerFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerPayload>[];
+                };
+                create: {
+                    args: Prisma.EventHandlerCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerPayload>;
+                };
+                createMany: {
+                    args: Prisma.EventHandlerCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                delete: {
+                    args: Prisma.EventHandlerDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerPayload>;
+                };
+                update: {
+                    args: Prisma.EventHandlerUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.EventHandlerDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.EventHandlerUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                upsert: {
+                    args: Prisma.EventHandlerUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerPayload>;
+                };
+                aggregate: {
+                    args: Prisma.EventHandlerAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateEventHandler>;
+                };
+                groupBy: {
+                    args: Prisma.EventHandlerGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.EventHandlerGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.EventHandlerCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.EventHandlerCountAggregateOutputType> | number;
+                };
+            };
+        };
+        WorkflowEvent: {
+            payload: Prisma.$WorkflowEventPayload<ExtArgs>;
+            fields: Prisma.WorkflowEventFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WorkflowEventFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowEventPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WorkflowEventFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowEventPayload>;
+                };
+                findFirst: {
+                    args: Prisma.WorkflowEventFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowEventPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WorkflowEventFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowEventPayload>;
+                };
+                findMany: {
+                    args: Prisma.WorkflowEventFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowEventPayload>[];
+                };
+                create: {
+                    args: Prisma.WorkflowEventCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowEventPayload>;
+                };
+                createMany: {
+                    args: Prisma.WorkflowEventCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                delete: {
+                    args: Prisma.WorkflowEventDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowEventPayload>;
+                };
+                update: {
+                    args: Prisma.WorkflowEventUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowEventPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WorkflowEventDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WorkflowEventUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                upsert: {
+                    args: Prisma.WorkflowEventUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkflowEventPayload>;
+                };
+                aggregate: {
+                    args: Prisma.WorkflowEventAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWorkflowEvent>;
+                };
+                groupBy: {
+                    args: Prisma.WorkflowEventGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkflowEventGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WorkflowEventCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkflowEventCountAggregateOutputType> | number;
+                };
+            };
+        };
+        EventHandlerExecution: {
+            payload: Prisma.$EventHandlerExecutionPayload<ExtArgs>;
+            fields: Prisma.EventHandlerExecutionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.EventHandlerExecutionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerExecutionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.EventHandlerExecutionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerExecutionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.EventHandlerExecutionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerExecutionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.EventHandlerExecutionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerExecutionPayload>;
+                };
+                findMany: {
+                    args: Prisma.EventHandlerExecutionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerExecutionPayload>[];
+                };
+                create: {
+                    args: Prisma.EventHandlerExecutionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerExecutionPayload>;
+                };
+                createMany: {
+                    args: Prisma.EventHandlerExecutionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                delete: {
+                    args: Prisma.EventHandlerExecutionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerExecutionPayload>;
+                };
+                update: {
+                    args: Prisma.EventHandlerExecutionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerExecutionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.EventHandlerExecutionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.EventHandlerExecutionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                upsert: {
+                    args: Prisma.EventHandlerExecutionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$EventHandlerExecutionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.EventHandlerExecutionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateEventHandlerExecution>;
+                };
+                groupBy: {
+                    args: Prisma.EventHandlerExecutionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.EventHandlerExecutionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.EventHandlerExecutionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.EventHandlerExecutionCountAggregateOutputType> | number;
+                };
+            };
+        };
         DomainEvent: {
             payload: Prisma.$DomainEventPayload<ExtArgs>;
             fields: Prisma.DomainEventFieldRefs;
@@ -4116,6 +4451,79 @@ export declare const DocumentRequirementRuleScalarFieldEnum: {
     readonly updatedAt: "updatedAt";
 };
 export type DocumentRequirementRuleScalarFieldEnum = (typeof DocumentRequirementRuleScalarFieldEnum)[keyof typeof DocumentRequirementRuleScalarFieldEnum];
+export declare const EventChannelScalarFieldEnum: {
+    readonly id: "id";
+    readonly tenantId: "tenantId";
+    readonly code: "code";
+    readonly name: "name";
+    readonly description: "description";
+    readonly enabled: "enabled";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type EventChannelScalarFieldEnum = (typeof EventChannelScalarFieldEnum)[keyof typeof EventChannelScalarFieldEnum];
+export declare const EventTypeScalarFieldEnum: {
+    readonly id: "id";
+    readonly tenantId: "tenantId";
+    readonly channelId: "channelId";
+    readonly code: "code";
+    readonly name: "name";
+    readonly description: "description";
+    readonly payloadSchema: "payloadSchema";
+    readonly enabled: "enabled";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type EventTypeScalarFieldEnum = (typeof EventTypeScalarFieldEnum)[keyof typeof EventTypeScalarFieldEnum];
+export declare const EventHandlerScalarFieldEnum: {
+    readonly id: "id";
+    readonly tenantId: "tenantId";
+    readonly eventTypeId: "eventTypeId";
+    readonly name: "name";
+    readonly description: "description";
+    readonly handlerType: "handlerType";
+    readonly config: "config";
+    readonly priority: "priority";
+    readonly enabled: "enabled";
+    readonly maxRetries: "maxRetries";
+    readonly retryDelayMs: "retryDelayMs";
+    readonly filterCondition: "filterCondition";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type EventHandlerScalarFieldEnum = (typeof EventHandlerScalarFieldEnum)[keyof typeof EventHandlerScalarFieldEnum];
+export declare const WorkflowEventScalarFieldEnum: {
+    readonly id: "id";
+    readonly tenantId: "tenantId";
+    readonly eventTypeId: "eventTypeId";
+    readonly payload: "payload";
+    readonly correlationId: "correlationId";
+    readonly causationId: "causationId";
+    readonly source: "source";
+    readonly actorId: "actorId";
+    readonly actorType: "actorType";
+    readonly status: "status";
+    readonly error: "error";
+    readonly processedAt: "processedAt";
+    readonly createdAt: "createdAt";
+};
+export type WorkflowEventScalarFieldEnum = (typeof WorkflowEventScalarFieldEnum)[keyof typeof WorkflowEventScalarFieldEnum];
+export declare const EventHandlerExecutionScalarFieldEnum: {
+    readonly id: "id";
+    readonly eventId: "eventId";
+    readonly handlerId: "handlerId";
+    readonly status: "status";
+    readonly attempt: "attempt";
+    readonly input: "input";
+    readonly output: "output";
+    readonly error: "error";
+    readonly errorCode: "errorCode";
+    readonly startedAt: "startedAt";
+    readonly completedAt: "completedAt";
+    readonly durationMs: "durationMs";
+    readonly createdAt: "createdAt";
+};
+export type EventHandlerExecutionScalarFieldEnum = (typeof EventHandlerExecutionScalarFieldEnum)[keyof typeof EventHandlerExecutionScalarFieldEnum];
 export declare const DomainEventScalarFieldEnum: {
     readonly id: "id";
     readonly eventType: "eventType";
@@ -4559,6 +4967,51 @@ export declare const DocumentRequirementRuleOrderByRelevanceFieldEnum: {
     readonly allowedMimeTypes: "allowedMimeTypes";
 };
 export type DocumentRequirementRuleOrderByRelevanceFieldEnum = (typeof DocumentRequirementRuleOrderByRelevanceFieldEnum)[keyof typeof DocumentRequirementRuleOrderByRelevanceFieldEnum];
+export declare const EventChannelOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly tenantId: "tenantId";
+    readonly code: "code";
+    readonly name: "name";
+    readonly description: "description";
+};
+export type EventChannelOrderByRelevanceFieldEnum = (typeof EventChannelOrderByRelevanceFieldEnum)[keyof typeof EventChannelOrderByRelevanceFieldEnum];
+export declare const EventTypeOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly tenantId: "tenantId";
+    readonly channelId: "channelId";
+    readonly code: "code";
+    readonly name: "name";
+    readonly description: "description";
+};
+export type EventTypeOrderByRelevanceFieldEnum = (typeof EventTypeOrderByRelevanceFieldEnum)[keyof typeof EventTypeOrderByRelevanceFieldEnum];
+export declare const EventHandlerOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly tenantId: "tenantId";
+    readonly eventTypeId: "eventTypeId";
+    readonly name: "name";
+    readonly description: "description";
+    readonly filterCondition: "filterCondition";
+};
+export type EventHandlerOrderByRelevanceFieldEnum = (typeof EventHandlerOrderByRelevanceFieldEnum)[keyof typeof EventHandlerOrderByRelevanceFieldEnum];
+export declare const WorkflowEventOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly tenantId: "tenantId";
+    readonly eventTypeId: "eventTypeId";
+    readonly correlationId: "correlationId";
+    readonly causationId: "causationId";
+    readonly source: "source";
+    readonly actorId: "actorId";
+    readonly error: "error";
+};
+export type WorkflowEventOrderByRelevanceFieldEnum = (typeof WorkflowEventOrderByRelevanceFieldEnum)[keyof typeof WorkflowEventOrderByRelevanceFieldEnum];
+export declare const EventHandlerExecutionOrderByRelevanceFieldEnum: {
+    readonly id: "id";
+    readonly eventId: "eventId";
+    readonly handlerId: "handlerId";
+    readonly error: "error";
+    readonly errorCode: "errorCode";
+};
+export type EventHandlerExecutionOrderByRelevanceFieldEnum = (typeof EventHandlerExecutionOrderByRelevanceFieldEnum)[keyof typeof EventHandlerExecutionOrderByRelevanceFieldEnum];
 export declare const DomainEventOrderByRelevanceFieldEnum: {
     readonly id: "id";
     readonly eventType: "eventType";
@@ -4683,6 +5136,22 @@ export type EnumPaymentMethodChangeStatusFieldRefInput<$PrismaModel> = FieldRefI
  * Reference to a field of type 'DocumentRequirementContext'
  */
 export type EnumDocumentRequirementContextFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DocumentRequirementContext'>;
+/**
+ * Reference to a field of type 'EventHandlerType'
+ */
+export type EnumEventHandlerTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'EventHandlerType'>;
+/**
+ * Reference to a field of type 'ActorType'
+ */
+export type EnumActorTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ActorType'>;
+/**
+ * Reference to a field of type 'WorkflowEventStatus'
+ */
+export type EnumWorkflowEventStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'WorkflowEventStatus'>;
+/**
+ * Reference to a field of type 'ExecutionStatus'
+ */
+export type EnumExecutionStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ExecutionStatus'>;
 /**
  * Batch Payload for updateMany & deleteMany & createMany
  */
@@ -4823,6 +5292,11 @@ export type GlobalOmitConfig = {
     contractTermination?: Prisma.ContractTerminationOmit;
     paymentMethodChangeRequest?: Prisma.PaymentMethodChangeRequestOmit;
     documentRequirementRule?: Prisma.DocumentRequirementRuleOmit;
+    eventChannel?: Prisma.EventChannelOmit;
+    eventType?: Prisma.EventTypeOmit;
+    eventHandler?: Prisma.EventHandlerOmit;
+    workflowEvent?: Prisma.WorkflowEventOmit;
+    eventHandlerExecution?: Prisma.EventHandlerExecutionOmit;
     domainEvent?: Prisma.DomainEventOmit;
 };
 export type LogLevel = 'info' | 'query' | 'warn' | 'error';

package/dist/generated/client/internal/prismaNamespace.js

@@ -113,6 +113,11 @@ export const ModelName = {
     ContractTermination: 'ContractTermination',
     PaymentMethodChangeRequest: 'PaymentMethodChangeRequest',
     DocumentRequirementRule: 'DocumentRequirementRule',
+    EventChannel: 'EventChannel',
+    EventType: 'EventType',
+    EventHandler: 'EventHandler',
+    WorkflowEvent: 'WorkflowEvent',
+    EventHandlerExecution: 'EventHandlerExecution',
     DomainEvent: 'DomainEvent'
 };
 /**
@@ -764,6 +769,74 @@ export const DocumentRequirementRuleScalarFieldEnum = {
     createdAt: 'createdAt',
     updatedAt: 'updatedAt'
 };
+export const EventChannelScalarFieldEnum = {
+    id: 'id',
+    tenantId: 'tenantId',
+    code: 'code',
+    name: 'name',
+    description: 'description',
+    enabled: 'enabled',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+};
+export const EventTypeScalarFieldEnum = {
+    id: 'id',
+    tenantId: 'tenantId',
+    channelId: 'channelId',
+    code: 'code',
+    name: 'name',
+    description: 'description',
+    payloadSchema: 'payloadSchema',
+    enabled: 'enabled',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+};
+export const EventHandlerScalarFieldEnum = {
+    id: 'id',
+    tenantId: 'tenantId',
+    eventTypeId: 'eventTypeId',
+    name: 'name',
+    description: 'description',
+    handlerType: 'handlerType',
+    config: 'config',
+    priority: 'priority',
+    enabled: 'enabled',
+    maxRetries: 'maxRetries',
+    retryDelayMs: 'retryDelayMs',
+    filterCondition: 'filterCondition',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+};
+export const WorkflowEventScalarFieldEnum = {
+    id: 'id',
+    tenantId: 'tenantId',
+    eventTypeId: 'eventTypeId',
+    payload: 'payload',
+    correlationId: 'correlationId',
+    causationId: 'causationId',
+    source: 'source',
+    actorId: 'actorId',
+    actorType: 'actorType',
+    status: 'status',
+    error: 'error',
+    processedAt: 'processedAt',
+    createdAt: 'createdAt'
+};
+export const EventHandlerExecutionScalarFieldEnum = {
+    id: 'id',
+    eventId: 'eventId',
+    handlerId: 'handlerId',
+    status: 'status',
+    attempt: 'attempt',
+    input: 'input',
+    output: 'output',
+    error: 'error',
+    errorCode: 'errorCode',
+    startedAt: 'startedAt',
+    completedAt: 'completedAt',
+    durationMs: 'durationMs',
+    createdAt: 'createdAt'
+};
 export const DomainEventScalarFieldEnum = {
     id: 'id',
     eventType: 'eventType',
@@ -1154,6 +1227,46 @@ export const DocumentRequirementRuleOrderByRelevanceFieldEnum = {
     description: 'description',
     allowedMimeTypes: 'allowedMimeTypes'
 };
+export const EventChannelOrderByRelevanceFieldEnum = {
+    id: 'id',
+    tenantId: 'tenantId',
+    code: 'code',
+    name: 'name',
+    description: 'description'
+};
+export const EventTypeOrderByRelevanceFieldEnum = {
+    id: 'id',
+    tenantId: 'tenantId',
+    channelId: 'channelId',
+    code: 'code',
+    name: 'name',
+    description: 'description'
+};
+export const EventHandlerOrderByRelevanceFieldEnum = {
+    id: 'id',
+    tenantId: 'tenantId',
+    eventTypeId: 'eventTypeId',
+    name: 'name',
+    description: 'description',
+    filterCondition: 'filterCondition'
+};
+export const WorkflowEventOrderByRelevanceFieldEnum = {
+    id: 'id',
+    tenantId: 'tenantId',
+    eventTypeId: 'eventTypeId',
+    correlationId: 'correlationId',
+    causationId: 'causationId',
+    source: 'source',
+    actorId: 'actorId',
+    error: 'error'
+};
+export const EventHandlerExecutionOrderByRelevanceFieldEnum = {
+    id: 'id',
+    eventId: 'eventId',
+    handlerId: 'handlerId',
+    error: 'error',
+    errorCode: 'errorCode'
+};
 export const DomainEventOrderByRelevanceFieldEnum = {
     id: 'id',
     eventType: 'eventType',