@openora/core 0.4.1-canary.33 → 0.4.1-canary.34

package/dist/contracts/schemas/events.d.ts

@@ -1,6 +1,8 @@
 import * as z from 'zod';
 export declare const domainEventSchemas: {
     readonly 'identity.user.registered': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'identity.user.login': z.ZodObject<{
@@ -16,6 +18,8 @@ export declare const domainEventSchemas: {
         attemptsRemaining: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
     readonly 'identity.user.logout': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'identity.user.phone_login': z.ZodObject<{
@@ -25,9 +29,13 @@ export declare const domainEventSchemas: {
         method: z.ZodLiteral<"phone">;
     }, z.core.$strip>;
     readonly 'identity.phone_otp.requested': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'identity.phone_otp.cancelled': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
         reason: z.ZodEnum<{
             max_attempts: "max_attempts";
@@ -42,6 +50,8 @@ export declare const domainEventSchemas: {
         lockoutUntil: z.ZodISODateTime;
     }, z.core.$strip>;
     readonly 'identity.user.unlocked': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
         email: z.ZodEmail;
         actorId: z.ZodUUID;
@@ -49,34 +59,52 @@ export declare const domainEventSchemas: {
         previousLockoutUntil: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
     }, z.core.$strip>;
     readonly 'identity.2fa.enabled': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'identity.2fa.disabled': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'identity.password.reset': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'identity.email.verified': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'identity.profile.updated': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'identity.user.deactivated': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
         actorId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'identity.user.reactivated': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
         actorId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'identity.session.revoked': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
         sessionId: z.ZodUUID;
         actorId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>;
     readonly 'identity.sessions.revoked_all': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
         actorId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>;
@@ -105,6 +133,8 @@ export declare const domainEventSchemas: {
         amount: z.ZodString;
         currency: z.ZodString;
         transactionId: z.ZodUUID;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     readonly 'wallet.withdrawal.approved': z.ZodObject<{
         userId: z.ZodUUID;
@@ -112,6 +142,8 @@ export declare const domainEventSchemas: {
         currency: z.ZodString;
         transactionId: z.ZodUUID;
         adminId: z.ZodUUID;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     readonly 'wallet.withdrawal.rejected': z.ZodObject<{
         userId: z.ZodUUID;
@@ -120,6 +152,8 @@ export declare const domainEventSchemas: {
         transactionId: z.ZodUUID;
         adminId: z.ZodUUID;
         reason: z.ZodString;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     readonly 'wallet.withdrawal.failed': z.ZodObject<{
         userId: z.ZodUUID;
@@ -144,14 +178,20 @@ export declare const domainEventSchemas: {
         userId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'chat.user.blocked': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         blockerId: z.ZodUUID;
         blockedId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'chat.user.unblocked': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         blockerId: z.ZodUUID;
         blockedId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'chat.room.created': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         roomId: z.ZodUUID;
         name: z.ZodString;
         slug: z.ZodString;
@@ -159,6 +199,8 @@ export declare const domainEventSchemas: {
         actorId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>;
     readonly 'chat.room.deleted': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         roomId: z.ZodUUID;
         actorId: z.ZodOptional<z.ZodUUID>;
         before: z.ZodObject<{
@@ -168,6 +210,8 @@ export declare const domainEventSchemas: {
         }, z.core.$strip>;
     }, z.core.$strip>;
     readonly 'chat.room.updated': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         roomId: z.ZodUUID;
         actorId: z.ZodOptional<z.ZodUUID>;
         before: z.ZodObject<{
@@ -182,28 +226,40 @@ export declare const domainEventSchemas: {
         }, z.core.$strip>;
     }, z.core.$strip>;
     readonly 'chat.private_room.created': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         roomId: z.ZodUUID;
         creatorId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'chat.room.member.joined': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         roomId: z.ZodUUID;
         userId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'chat.room.member.left': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         roomId: z.ZodUUID;
         userId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'chat.room.member.kicked': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         roomId: z.ZodUUID;
         userId: z.ZodUUID;
         kickedBy: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'chat.room.member.banned': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         roomId: z.ZodUUID;
         userId: z.ZodUUID;
         bannedBy: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'compliance.geo-rule.added': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         countryCode: z.ZodString;
         action: z.ZodEnum<{
             allow: "allow";
@@ -212,14 +268,20 @@ export declare const domainEventSchemas: {
         actorId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>;
     readonly 'compliance.limit.upserted': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
         limitId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'compliance.limit.removed': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
         limitId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'rg.limit.set': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
         actorId: z.ZodUUID;
         limitId: z.ZodUUID;
@@ -246,6 +308,8 @@ export declare const domainEventSchemas: {
         userId: z.ZodUUID;
         exclusionId: z.ZodUUID;
         expiresAt: z.ZodISODateTime;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     readonly 'rg.self_exclusion.activated': z.ZodObject<{
         actorId: z.ZodUUID;
@@ -254,6 +318,8 @@ export declare const domainEventSchemas: {
         exclusionId: z.ZodUUID;
         isPermanent: z.ZodBoolean;
         expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     readonly 'rg.self_exclusion.lifted': z.ZodObject<{
         actorId: z.ZodUUID;
@@ -264,11 +330,13 @@ export declare const domainEventSchemas: {
             cooling_off: "cooling_off";
             self_exclusion: "self_exclusion";
         }>;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     readonly 'rg.exclusion.login_blocked': z.ZodObject<{
-        userId: z.ZodUUID;
         ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'compliance.kyc.updated': z.ZodObject<{
         userId: z.ZodUUID;
@@ -291,6 +359,8 @@ export declare const domainEventSchemas: {
         }>;
     }, z.core.$strip>;
     readonly 'compliance.kyc.submitted': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
         referenceId: z.ZodString;
         provider: z.ZodString;
@@ -304,34 +374,50 @@ export declare const domainEventSchemas: {
         userId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'cms.page.published': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         pageId: z.ZodUUID;
         slug: z.ZodString;
     }, z.core.$strip>;
     readonly 'cms.page.created': z.ZodObject<{
         pageId: z.ZodUUID;
         actorId: z.ZodUUID;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     readonly 'cms.page.updated': z.ZodObject<{
         pageId: z.ZodUUID;
         actorId: z.ZodUUID;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     readonly 'cms.page.deleted': z.ZodObject<{
         pageId: z.ZodUUID;
         actorId: z.ZodUUID;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     readonly 'cms.banner.created': z.ZodObject<{
         bannerId: z.ZodUUID;
         actorId: z.ZodUUID;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     readonly 'cms.banner.updated': z.ZodObject<{
         bannerId: z.ZodUUID;
         actorId: z.ZodUUID;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     readonly 'cms.banner.deleted': z.ZodObject<{
         bannerId: z.ZodUUID;
         actorId: z.ZodUUID;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     readonly 'iam.invitation.accepted': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         email: z.ZodEmail;
         roleId: z.ZodUUID;
         invitationId: z.ZodUUID;
@@ -339,20 +425,28 @@ export declare const domainEventSchemas: {
     readonly 'iam.role.created': z.ZodObject<{
         roleId: z.ZodUUID;
         actorId: z.ZodUUID;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         name: z.ZodString;
     }, z.core.$strip>;
     readonly 'iam.role.updated': z.ZodObject<{
         roleId: z.ZodUUID;
         actorId: z.ZodUUID;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         name: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     readonly 'iam.role.deleted': z.ZodObject<{
         roleId: z.ZodUUID;
         actorId: z.ZodUUID;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     readonly 'iam.role.permissions.changed': z.ZodObject<{
         roleId: z.ZodUUID;
         actorId: z.ZodUUID;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         before: z.ZodArray<z.ZodObject<{
             resource: z.ZodString;
             level: z.ZodEnum<{
@@ -373,11 +467,15 @@ export declare const domainEventSchemas: {
     readonly 'iam.role.assigned': z.ZodObject<{
         roleId: z.ZodUUID;
         actorId: z.ZodUUID;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'iam.role.revoked': z.ZodObject<{
         roleId: z.ZodUUID;
         actorId: z.ZodUUID;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         userId: z.ZodUUID;
     }, z.core.$strip>;
     readonly 'tag.player.assigned': z.ZodObject<{
@@ -396,6 +494,8 @@ export declare const domainEventSchemas: {
             kyc_rejected: "kyc_rejected";
             test_account: "test_account";
         }>;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     readonly 'tag.player.removed': z.ZodObject<{
         actorId: z.ZodUUID;
@@ -413,8 +513,12 @@ export declare const domainEventSchemas: {
             kyc_rejected: "kyc_rejected";
             test_account: "test_account";
         }>;
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     readonly 'tag.rule.upserted': z.ZodObject<{
+        ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         tagKey: z.ZodEnum<{
             high_roller: "high_roller";
             vip: "vip";

package/dist/contracts/schemas/events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/contracts/schemas/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAoCzB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2PrB,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,kBAAkB,CAAC;AAC9D,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,eAAe,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAIpG,eAAO,MAAM,mBAAmB,EAAE,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAmBxE,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,eAAO,MAAM,oBAAoB,EAAsC,eAAe,EAAE,CAAC;AAEzF,sIAAsI;AACtI,wBAAgB,YAAY,IAAI,aAAa,CAAC;IAAE,KAAK,EAAE,eAAe,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAKzF"}
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/contracts/schemas/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAyCzB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyPrB,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,kBAAkB,CAAC;AAC9D,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,eAAe,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAIpG,eAAO,MAAM,mBAAmB,EAAE,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAmBxE,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,eAAO,MAAM,oBAAoB,EAAsC,eAAe,EAAE,CAAC;AAEzF,sIAAsI;AACtI,wBAAgB,YAAY,IAAI,aAAa,CAAC;IAAE,KAAK,EAAE,eAAe,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAKzF"}

package/dist/contracts/schemas/events.js

@@ -1,21 +1,26 @@
 import * as z from 'zod';
-import { MoneyAmountSchema, TimestampSchema, UuidSchema } from './common.js';
+import { ClientMetaSchema, MoneyAmountSchema, TimestampSchema, UuidSchema } from './common.js';
 import { GeoRuleActionSchema, LimitTypeSchema, LimitPeriodSchema, ExclusionKindSchema, } from './compliance.js';
 import { TagKeySchema } from './tag.js';
 import { CurrencyCodeSchema, CountryCodeSchema } from './igaming-config.js';
 import { PermissionLevelSchema } from './iam.js';
 import { KycStatusSchema } from './player.js';
-const iamRoleEventBase = z.object({ roleId: UuidSchema, actorId: UuidSchema });
-const cmsPageEventBase = z.object({ pageId: UuidSchema, actorId: UuidSchema });
-const cmsBannerEventBase = z.object({ bannerId: UuidSchema, actorId: UuidSchema });
+// Optional request-origin metadata shared by HTTP-triggered events; both fields may be absent.
+const authContextBase = ClientMetaSchema.partial();
+const iamRoleEventBase = z
+    .object({ roleId: UuidSchema, actorId: UuidSchema })
+    .merge(authContextBase);
+const cmsPageEventBase = z
+    .object({ pageId: UuidSchema, actorId: UuidSchema })
+    .merge(authContextBase);
+const cmsBannerEventBase = z
+    .object({ bannerId: UuidSchema, actorId: UuidSchema })
+    .merge(authContextBase);
 const actorReasonBase = z.object({ actorId: UuidSchema, reason: z.string() });
-const tagPlayerEventBase = actorReasonBase.extend({ playerId: UuidSchema, tagKey: TagKeySchema });
+const tagPlayerEventBase = actorReasonBase
+    .extend({ playerId: UuidSchema, tagKey: TagKeySchema })
+    .merge(authContextBase);
 const permissionLevelEntries = z.array(z.object({ resource: z.string(), level: PermissionLevelSchema }));
-// Optional request-origin metadata shared by auth events; both fields may be absent.
-const authContextBase = z.object({
-    ip: z.string().nullable().optional(),
-    userAgent: z.string().nullable().optional(),
-});
 // Shared shape for every wallet money-movement event. Exact decimal string + currency.
 const walletTxnBase = z.object({
     userId: UuidSchema,
@@ -24,20 +29,20 @@ const walletTxnBase = z.object({
     transactionId: UuidSchema,
 });
 export const domainEventSchemas = {
-    'identity.user.registered': z.object({ userId: UuidSchema }),
+    'identity.user.registered': authContextBase.extend({ userId: UuidSchema }),
     'identity.user.login': authContextBase.extend({ userId: UuidSchema }),
     'identity.user.login.failed': authContextBase.extend({
         email: z.email(),
         reason: z.string().nullable().optional(),
         attemptsRemaining: z.number().int().optional(),
     }),
-    'identity.user.logout': z.object({ userId: UuidSchema }),
+    'identity.user.logout': authContextBase.extend({ userId: UuidSchema }),
     'identity.user.phone_login': authContextBase.extend({
         userId: UuidSchema,
         method: z.literal('phone'),
     }),
-    'identity.phone_otp.requested': z.object({ userId: UuidSchema }),
-    'identity.phone_otp.cancelled': z.object({
+    'identity.phone_otp.requested': authContextBase.extend({ userId: UuidSchema }),
+    'identity.phone_otp.cancelled': authContextBase.extend({
         userId: UuidSchema,
         reason: z.enum(['max_attempts', 'new_otp_requested']),
     }),
@@ -46,29 +51,29 @@ export const domainEventSchemas = {
         email: z.email(),
         lockoutUntil: TimestampSchema,
     }),
-    'identity.user.unlocked': z.object({
+    'identity.user.unlocked': authContextBase.extend({
         userId: UuidSchema,
         email: z.email(),
         actorId: UuidSchema,
         previousFailedAttempts: z.number().int().optional(),
         previousLockoutUntil: TimestampSchema.nullable().optional(),
     }),
-    'identity.2fa.enabled': z.object({ userId: UuidSchema }),
-    'identity.2fa.disabled': z.object({ userId: UuidSchema }),
-    'identity.password.reset': z.object({ userId: UuidSchema }),
-    'identity.email.verified': z.object({ userId: UuidSchema }),
-    'identity.profile.updated': z.object({ userId: UuidSchema }),
+    'identity.2fa.enabled': authContextBase.extend({ userId: UuidSchema }),
+    'identity.2fa.disabled': authContextBase.extend({ userId: UuidSchema }),
+    'identity.password.reset': authContextBase.extend({ userId: UuidSchema }),
+    'identity.email.verified': authContextBase.extend({ userId: UuidSchema }),
+    'identity.profile.updated': authContextBase.extend({ userId: UuidSchema }),
     // An admin toggled a user's active status (the only user-lifecycle flow today;
     // users are deactivated, never hard-deleted). userId = subject, actorId = the
     // admin who acted (for a complete audit trail).
-    'identity.user.deactivated': z.object({ userId: UuidSchema, actorId: UuidSchema }),
-    'identity.user.reactivated': z.object({ userId: UuidSchema, actorId: UuidSchema }),
-    'identity.session.revoked': z.object({
+    'identity.user.deactivated': authContextBase.extend({ userId: UuidSchema, actorId: UuidSchema }),
+    'identity.user.reactivated': authContextBase.extend({ userId: UuidSchema, actorId: UuidSchema }),
+    'identity.session.revoked': authContextBase.extend({
         userId: UuidSchema,
         sessionId: UuidSchema,
         actorId: UuidSchema.optional(),
     }),
-    'identity.sessions.revoked_all': z.object({
+    'identity.sessions.revoked_all': authContextBase.extend({
         userId: UuidSchema,
         actorId: UuidSchema.optional(),
     }),
@@ -82,16 +87,17 @@ export const domainEventSchemas = {
     'wallet.withdrawal.completed': walletTxnBase,
     // A player requested a withdrawal; funds are held (balance debited) and the
     // request enters the back-office approval queue as `pending`.
-    'wallet.withdrawal.requested': walletTxnBase,
+    'wallet.withdrawal.requested': walletTxnBase.merge(authContextBase),
     // A payments admin approved a pending withdrawal; it moves to `processing` and
     // is sent to the PSP/Fireblocks rail. `adminId` is the acting reviewer.
-    'wallet.withdrawal.approved': walletTxnBase.extend({ adminId: UuidSchema }),
+    'wallet.withdrawal.approved': walletTxnBase
+        .extend({ adminId: UuidSchema })
+        .merge(authContextBase),
     // A payments admin rejected a pending withdrawal; held funds are returned to the
     // player balance. `adminId` is the acting reviewer; `reason` is mandatory.
-    'wallet.withdrawal.rejected': walletTxnBase.extend({
-        adminId: UuidSchema,
-        reason: z.string(),
-    }),
+    'wallet.withdrawal.rejected': walletTxnBase
+        .extend({ adminId: UuidSchema, reason: z.string() })
+        .merge(authContextBase),
     // An approved withdrawal failed at the PSP/Fireblocks rail; the held funds were
     // returned to the player balance and the transaction moved to `failed`.
     'wallet.withdrawal.failed': walletTxnBase.extend({ adminId: UuidSchema }),
@@ -109,50 +115,53 @@ export const domainEventSchemas = {
         userId: UuidSchema,
     }),
     // A player muted/unmuted another player's messages for themselves (ABC-45 AC11).
-    'chat.user.blocked': z.object({ blockerId: UuidSchema, blockedId: UuidSchema }),
-    'chat.user.unblocked': z.object({ blockerId: UuidSchema, blockedId: UuidSchema }),
+    'chat.user.blocked': authContextBase.extend({ blockerId: UuidSchema, blockedId: UuidSchema }),
+    'chat.user.unblocked': authContextBase.extend({ blockerId: UuidSchema, blockedId: UuidSchema }),
     // Admin room CRUD (actorId = acting admin UUID).
-    'chat.room.created': z.object({
+    'chat.room.created': authContextBase.extend({
         roomId: UuidSchema,
         name: z.string(),
         slug: z.string(),
         category: z.string(),
         actorId: UuidSchema.optional(),
     }),
-    'chat.room.deleted': z.object({
+    'chat.room.deleted': authContextBase.extend({
         roomId: UuidSchema,
         actorId: UuidSchema.optional(),
         before: z.object({ name: z.string(), slug: z.string(), category: z.string() }),
     }),
-    'chat.room.updated': z.object({
+    'chat.room.updated': authContextBase.extend({
         roomId: UuidSchema,
         actorId: UuidSchema.optional(),
         before: z.object({ name: z.string(), slug: z.string(), category: z.string() }),
         after: z.object({ name: z.string(), slug: z.string(), category: z.string() }),
     }),
     // Private room lifecycle: creation and member membership changes.
-    'chat.private_room.created': z.object({ roomId: UuidSchema, creatorId: UuidSchema }),
-    'chat.room.member.joined': z.object({ roomId: UuidSchema, userId: UuidSchema }),
-    'chat.room.member.left': z.object({ roomId: UuidSchema, userId: UuidSchema }),
-    'chat.room.member.kicked': z.object({
+    'chat.private_room.created': authContextBase.extend({
+        roomId: UuidSchema,
+        creatorId: UuidSchema,
+    }),
+    'chat.room.member.joined': authContextBase.extend({ roomId: UuidSchema, userId: UuidSchema }),
+    'chat.room.member.left': authContextBase.extend({ roomId: UuidSchema, userId: UuidSchema }),
+    'chat.room.member.kicked': authContextBase.extend({
         roomId: UuidSchema,
         userId: UuidSchema,
         kickedBy: UuidSchema,
     }),
-    'chat.room.member.banned': z.object({
+    'chat.room.member.banned': authContextBase.extend({
         roomId: UuidSchema,
         userId: UuidSchema,
         bannedBy: UuidSchema,
     }),
     // An admin added or changed a geo (country) rule (regulatory). `actorId` is the
     // acting admin so the audit log can attribute the mutation.
-    'compliance.geo-rule.added': z.object({
+    'compliance.geo-rule.added': authContextBase.extend({
         countryCode: CountryCodeSchema,
         action: GeoRuleActionSchema,
         actorId: UuidSchema.optional(),
     }),
-    'compliance.limit.upserted': z.object({ userId: UuidSchema, limitId: UuidSchema }),
-    'compliance.limit.removed': z.object({ userId: UuidSchema, limitId: UuidSchema }),
+    'compliance.limit.upserted': authContextBase.extend({ userId: UuidSchema, limitId: UuidSchema }),
+    'compliance.limit.removed': authContextBase.extend({ userId: UuidSchema, limitId: UuidSchema }),
     // Responsible-Gambling admin actions. `userId` = the subject player, `actorId` =
     // the acting admin (the envelope carries no caller, so it is explicit for the audit
     // trail). login_blocked is system-driven (no actor) and a failure outcome.
@@ -160,7 +169,7 @@ export const domainEventSchemas = {
     // money-type limits carry amount (minutes null), the session-type limit
     // carries minutes (amount null). previous* mirrors the prior row's value, null
     // when this is the first limit of that (type, period).
-    'rg.limit.set': z.object({
+    'rg.limit.set': authContextBase.extend({
         userId: UuidSchema,
         actorId: UuidSchema,
         limitId: UuidSchema,
@@ -171,27 +180,21 @@ export const domainEventSchemas = {
         previousAmount: MoneyAmountSchema.nullable(),
         previousMinutes: z.number().int().nullable(),
     }),
-    'rg.cooling_off.activated': actorReasonBase.extend({
-        userId: UuidSchema,
-        exclusionId: UuidSchema,
-        expiresAt: TimestampSchema,
-    }),
-    'rg.self_exclusion.activated': actorReasonBase.extend({
+    'rg.cooling_off.activated': actorReasonBase
+        .extend({ userId: UuidSchema, exclusionId: UuidSchema, expiresAt: TimestampSchema })
+        .merge(authContextBase),
+    'rg.self_exclusion.activated': actorReasonBase
+        .extend({
         userId: UuidSchema,
         exclusionId: UuidSchema,
         isPermanent: z.boolean(),
         expiresAt: TimestampSchema.nullable(),
-    }),
-    'rg.self_exclusion.lifted': actorReasonBase.extend({
-        userId: UuidSchema,
-        exclusionId: UuidSchema,
-        kind: ExclusionKindSchema,
-    }),
-    'rg.exclusion.login_blocked': z.object({
-        userId: UuidSchema,
-        ip: z.string().nullable().optional(),
-        userAgent: z.string().nullable().optional(),
-    }),
+    })
+        .merge(authContextBase),
+    'rg.self_exclusion.lifted': actorReasonBase
+        .extend({ userId: UuidSchema, exclusionId: UuidSchema, kind: ExclusionKindSchema })
+        .merge(authContextBase),
+    'rg.exclusion.login_blocked': authContextBase.extend({ userId: UuidSchema }),
     // A player's KYC status changed. userId = subject player; actorId = the admin who
     // acted, or null for system-driven changes (vendor decision, webhook, threshold
     // re-KYC). before/after status records the transition for the audit log.
@@ -203,7 +206,7 @@ export const domainEventSchemas = {
     }),
     // A player submitted KYC documents; a verification record was created and sent to
     // the provider. userId = the submitting player; referenceId = the provider reference.
-    'compliance.kyc.submitted': z.object({
+    'compliance.kyc.submitted': authContextBase.extend({
         userId: UuidSchema,
         referenceId: z.string(),
         provider: z.string(),
@@ -215,7 +218,7 @@ export const domainEventSchemas = {
         reason: z.string(),
     }),
     'notifications.created': z.object({ notificationId: UuidSchema, userId: UuidSchema }),
-    'cms.page.published': z.object({ pageId: UuidSchema, slug: z.string() }),
+    'cms.page.published': authContextBase.extend({ pageId: UuidSchema, slug: z.string() }),
     'cms.page.created': cmsPageEventBase,
     'cms.page.updated': cmsPageEventBase,
     'cms.page.deleted': cmsPageEventBase,
@@ -225,7 +228,7 @@ export const domainEventSchemas = {
     // Emitted when an admin invitation token is accepted. The consumer (identity
     // module or an overlay) provisions the user account and completes the role
     // assignment by resolving the userId from the email.
-    'iam.invitation.accepted': z.object({
+    'iam.invitation.accepted': authContextBase.extend({
         email: z.email(),
         roleId: UuidSchema,
         invitationId: UuidSchema,
@@ -252,7 +255,7 @@ export const domainEventSchemas = {
     'tag.player.assigned': tagPlayerEventBase,
     'tag.player.removed': tagPlayerEventBase,
     // Emitted after an admin creates or updates a tag rule configuration.
-    'tag.rule.upserted': z.object({
+    'tag.rule.upserted': authContextBase.extend({
         tagKey: TagKeySchema,
         actorId: UuidSchema,
         after: z.record(z.string(), z.unknown()),