@go-mondo/identity-sdk 0.0.2-beta.8 → 0.0.2-beta.9

package/dist/esm/activity/schema/base.test.js

@@ -0,0 +1,237 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateAppId } from '../../app/utils.js';
+import { ActivityIdPropertySchema, ActivityIdSchema, ActivityType, BaseInsertPayloadSchema, BaseSchema, BaseUpdatePayloadSchema, PerformedBySchema, PerformerType, SourceSchema, } from './base.js';
+import { generateActivityId } from './utils.js';
+describe('Activity Schema - Base', () => {
+    describe('ActivityType constants', () => {
+        test('should have correct activity type values', () => {
+            expect(ActivityType.UNKNOWN).toBe('unknown');
+            expect(ActivityType.NOTE).toBe('note');
+            expect(ActivityType.OPERATION).toBe('operation');
+            expect(ActivityType.AUTHORIZATION).toBe('authorization');
+            expect(ActivityType.AUTHENTICATION).toBe('authentication');
+        });
+    });
+    describe('PerformerType constants', () => {
+        test('should have correct performer type values', () => {
+            expect(PerformerType.SYSTEM).toBe('system');
+            expect(PerformerType.GUEST).toBe('guest');
+            expect(PerformerType.IDENTITY).toBe('identity');
+            expect(PerformerType.AUTOMATION).toBe('automation');
+            expect(PerformerType.INTEGRATION).toBe('integration');
+        });
+    });
+    describe('ActivityIdSchema', () => {
+        test('should accept valid activity ID', () => {
+            const id = generateActivityId();
+            const result = ActivityIdSchema(id);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBe(id);
+        });
+        test('should reject invalid activity ID format', () => {
+            expect(ActivityIdSchema('invalid_id')).toBeInstanceOf(type.errors);
+            expect(ActivityIdSchema('wrong_prefix_123')).toBeInstanceOf(type.errors);
+        });
+        test('should reject non-string values', () => {
+            expect(ActivityIdSchema(123)).toBeInstanceOf(type.errors);
+            expect(ActivityIdSchema(null)).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('ActivityIdPropertySchema', () => {
+        test('should accept valid id property', () => {
+            const payload = { id: generateActivityId() };
+            const result = ActivityIdPropertySchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should reject missing id', () => {
+            const result = ActivityIdPropertySchema({});
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('SourceSchema', () => {
+        test('should accept string source', () => {
+            const result = SourceSchema('api-request');
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBe('api-request');
+        });
+        test('should reject non-string values', () => {
+            expect(SourceSchema(123)).toBeInstanceOf(type.errors);
+            expect(SourceSchema(null)).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('PerformedBySchema', () => {
+        test('should accept valid performer with system type', () => {
+            const performer = {
+                type: 'system',
+                identifier: 'system-process',
+            };
+            const result = PerformedBySchema(performer);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(performer);
+        });
+        test('should accept valid performer with identity type', () => {
+            const performer = {
+                type: 'identity',
+                identifier: 'user@example.com',
+            };
+            const result = PerformedBySchema(performer);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(performer);
+        });
+        test('should accept all valid performer types', () => {
+            const types = [
+                'system',
+                'guest',
+                'identity',
+                'automation',
+                'integration',
+            ];
+            for (const performerType of types) {
+                const performer = {
+                    type: performerType,
+                    identifier: `test-${performerType}`,
+                };
+                const result = PerformedBySchema(performer);
+                expect(result).not.toBeInstanceOf(type.errors);
+            }
+        });
+        test('should reject invalid performer type', () => {
+            const performer = {
+                type: 'invalid',
+                identifier: 'test',
+            };
+            const result = PerformedBySchema(performer);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject missing fields', () => {
+            expect(PerformedBySchema({ type: 'system' })).toBeInstanceOf(type.errors);
+            expect(PerformedBySchema({ identifier: 'test' })).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('BaseSchema', () => {
+        test('should accept complete base activity', () => {
+            const activity = {
+                id: generateActivityId(),
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'web-app',
+                app: generateAppId(),
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: { key: 'value' },
+            };
+            const result = BaseSchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept activity without app', () => {
+            const activity = {
+                id: generateActivityId(),
+                performedBy: {
+                    type: 'system',
+                    identifier: 'background-job',
+                },
+                source: 'cron',
+                isMutateable: false,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = BaseSchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept activity with optional dates', () => {
+            const activity = {
+                id: generateActivityId(),
+                performedBy: {
+                    type: 'guest',
+                    identifier: 'anonymous',
+                },
+                source: 'public-api',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                deletedAt: new Date(),
+                deactivatedAt: new Date(),
+                metadata: {},
+            };
+            const result = BaseSchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject missing required fields', () => {
+            const activity = {
+                id: generateActivityId(),
+                performedBy: {
+                    type: 'system',
+                    identifier: 'test',
+                },
+                // missing source, isMutateable, dates, metadata
+            };
+            const result = BaseSchema(activity);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('BaseInsertPayloadSchema', () => {
+        test('should accept complete insert payload', () => {
+            const payload = {
+                id: generateActivityId(),
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user123',
+                },
+                metadata: { source: 'api' },
+            };
+            const result = BaseInsertPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept minimal insert payload', () => {
+            const payload = {};
+            const result = BaseInsertPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            // Should generate default ID
+            expect(result.id).toMatch(/^act_/);
+        });
+        test('should generate default ID when not provided', () => {
+            const payload = {
+                performedBy: {
+                    type: 'system',
+                    identifier: 'auto-process',
+                },
+            };
+            const result = BaseInsertPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result.id).toMatch(/^act_/);
+        });
+    });
+    describe('BaseUpdatePayloadSchema', () => {
+        test('should accept update with performer', () => {
+            const payload = {
+                performedBy: {
+                    type: 'automation',
+                    identifier: 'scheduled-task',
+                },
+                metadata: { updated: true },
+            };
+            const result = BaseUpdatePayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept empty update payload', () => {
+            const payload = {};
+            const result = BaseUpdatePayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept update with only metadata', () => {
+            const payload = {
+                metadata: { version: '2.0' },
+            };
+            const result = BaseUpdatePayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+    });
+});

package/dist/esm/activity/schema/schema.d.ts

@@ -12,7 +12,7 @@ export declare const ActivitySchema: import("arktype/internal/methods/object.ts"
     updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean> | Map<string, any>>;
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
     type: "authentication";
     status: "success" | "fail";
     identity: string;
@@ -30,7 +30,7 @@ export declare const ActivitySchema: import("arktype/internal/methods/object.ts"
     updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean> | Map<string, any>>;
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
     type: "authorization";
     status: "success" | "fail";
     message: string;
@@ -48,7 +48,7 @@ export declare const ActivitySchema: import("arktype/internal/methods/object.ts"
     updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean> | Map<string, any>>;
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
     type: "note";
     message: string;
 } | {
@@ -64,7 +64,7 @@ export declare const ActivitySchema: import("arktype/internal/methods/object.ts"
     updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean> | Map<string, any>>;
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
     type: "operation";
     operation: "delete" | "automation" | "create" | "update";
     message: string;
@@ -82,7 +82,7 @@ export declare const ActivitySchema: import("arktype/internal/methods/object.ts"
     updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean> | Map<string, any>>;
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
     type: "unknown";
     message: string;
 }, {}>;

package/dist/esm/activity/schema/schema.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schema.test.d.ts.map

package/dist/esm/activity/schema/schema.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.test.d.ts","sourceRoot":"","sources":["../../../../src/activity/schema/schema.test.ts"],"names":[],"mappings":""}

package/dist/esm/activity/schema/schema.test.js

@@ -0,0 +1,342 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateUserId } from '../../customer/schema.js';
+import { ActivityPayloadSchema, ActivitySchema, InsertActivityPayloadSchema, UpdateActivityPayloadSchema, } from './schema.js';
+import { generateActivityId } from './utils.js';
+describe('Activity Schema - Main', () => {
+    describe('ActivitySchema', () => {
+        test('should accept note activity', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'note',
+                message: 'Test note message',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'web-app',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = ActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept authentication activity', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'authentication',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                message: 'string',
+                identity: generateUserId(),
+                status: 'success',
+                source: 'login-form',
+                isMutateable: false,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: { method: 'email' },
+            };
+            const result = ActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept authorization activity', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'authorization',
+                performedBy: {
+                    type: 'system',
+                    identifier: 'auth-service',
+                },
+                message: 'string',
+                status: 'success',
+                source: 'rbac-check',
+                isMutateable: false,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: { resource: 'users' },
+            };
+            const result = ActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept operation activity', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'operation',
+                performedBy: {
+                    type: 'automation',
+                    identifier: 'data-sync',
+                },
+                message: 'string',
+                operation: 'delete',
+                target: generateUserId(),
+                source: 'cron-job',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: { operation: 'sync' },
+            };
+            const result = ActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept unknown activity', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'unknown',
+                performedBy: {
+                    type: 'guest',
+                    identifier: 'anonymous',
+                },
+                message: 'string',
+                source: 'external-api',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = ActivitySchema(activity);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid activity type', () => {
+            const activity = {
+                id: generateActivityId(),
+                type: 'invalid_type',
+                performedBy: {
+                    type: 'system',
+                    identifier: 'test',
+                },
+                source: 'test',
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = ActivitySchema(activity);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('ActivityPayloadSchema', () => {
+        test('should accept note activity payload', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'note',
+                message: 'Test note',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'web-app',
+                isMutateable: true,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { urgent: true },
+            };
+            const result = ActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept authentication activity payload', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'authentication',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                identity: generateUserId(),
+                message: 'string',
+                status: 'success',
+                source: 'mobile-app',
+                isMutateable: false,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { device: 'iPhone' },
+            };
+            const result = ActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept authorization activity payload', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'authorization',
+                performedBy: {
+                    type: 'system',
+                    identifier: 'permission-service',
+                },
+                message: 'string',
+                status: 'success',
+                source: 'api-gateway',
+                isMutateable: false,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { action: 'read' },
+            };
+            const result = ActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept operation activity payload', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'operation',
+                performedBy: {
+                    type: 'automation',
+                    identifier: 'backup-service',
+                },
+                operation: 'create',
+                target: 'target-id',
+                message: 'string',
+                source: 'scheduler',
+                isMutateable: true,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { backup_type: 'full' },
+            };
+            const result = ActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept unknown activity payload', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'unknown',
+                performedBy: {
+                    type: 'integration',
+                    identifier: 'webhook-handler',
+                },
+                message: 'string',
+                source: 'external-webhook',
+                isMutateable: true,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { webhook_id: 'wh_123' },
+            };
+            const result = ActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid activity type in payload', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'invalid_type',
+                performedBy: {
+                    type: 'system',
+                    identifier: 'test',
+                },
+                source: 'test',
+                isMutateable: true,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = ActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject payload with invalid date format', () => {
+            const payload = {
+                id: generateActivityId(),
+                type: 'note',
+                message: 'Test note',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'web-app',
+                isMutateable: true,
+                createdAt: 'invalid-date',
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = ActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('InsertActivityPayloadSchema', () => {
+        test('should accept valid insert payload', () => {
+            const payload = {
+                type: 'note',
+                message: 'New note',
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                metadata: { priority: 'high' },
+            };
+            const result = InsertActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept minimal insert payload', () => {
+            const payload = {
+                type: 'note',
+                message: 'Simple note',
+            };
+            const result = InsertActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            // Should generate ID automatically
+            expect(result.id).toMatch(/^act_/);
+        });
+        test('should reject insert payload missing required fields', () => {
+            const payload = {
+                type: 'note',
+                // missing message
+            };
+            const result = InsertActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject insert payload with invalid type', () => {
+            const payload = {
+                type: 'invalid_type',
+                message: 'Test message',
+            };
+            const result = InsertActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('UpdateActivityPayloadSchema', () => {
+        test('should accept update payload with message', () => {
+            const payload = {
+                type: 'note',
+                message: 'Updated message',
+                metadata: { updated: true },
+            };
+            const result = UpdateActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept update payload without message', () => {
+            const payload = {
+                type: 'note',
+                performedBy: {
+                    type: 'automation',
+                    identifier: 'update-service',
+                },
+                metadata: { auto_updated: true },
+            };
+            const result = UpdateActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept minimal update payload', () => {
+            const payload = {
+                type: 'note',
+            };
+            const result = UpdateActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject update payload with invalid type', () => {
+            const payload = {
+                type: 'invalid_type',
+                message: 'Updated message',
+            };
+            const result = UpdateActivityPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should accept update with only metadata', () => {
+            const payload = {
+                type: 'note',
+                metadata: { version: '2.0' },
+            };
+            const result = UpdateActivityPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+    });
+});

package/dist/esm/activity/schema/types/authentication.d.ts

@@ -17,7 +17,7 @@ export declare const AuthenticationActivitySchema: import("arktype/internal/meth
     updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean> | Map<string, any>>;
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
     type: "authentication";
     status: "success" | "fail";
     identity: string;

package/dist/esm/activity/schema/types/authentication.js

@@ -1,5 +1,5 @@
 import { type } from 'arktype';
-import { UserIdSchema } from '../../../customer/users/schema.js';
+import { UserIdSchema } from '../../../customer/schema.js';
 import { BasePayloadSchema, BaseSchema } from '../base.js';
 export const AuthenticationStatus = {
     SUCESS: 'success',

package/dist/esm/activity/schema/types/authentication.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=authentication.test.d.ts.map

package/dist/esm/activity/schema/types/authentication.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authentication.test.d.ts","sourceRoot":"","sources":["../../../../../src/activity/schema/types/authentication.test.ts"],"names":[],"mappings":""}