@go-mondo/identity-sdk 0.0.2-beta.3 → 0.0.2-beta.31

package/dist/esm/action/schema/operations/user-attribute-verification.test.js

@@ -0,0 +1,126 @@
+import { describe, expect, test } from 'vitest';
+import { generateUserId } from '../../../customer/schema.js';
+import { generateActionId } from '../utils.js';
+import { UserAttributeVerificationActionPayloadSchema, UserAttributeVerificationActionRequestSchema, } from './user-attribute-verification.js';
+describe('Action Schema Operations - User Attribute Verification', () => {
+    describe('UserAttributeVerificationActionPayloadSchema', () => {
+        test('should accept complete payload with email attribute', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'user-attribute-verification',
+                user: generateUserId(),
+                attribute: 'email',
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { key: 'value' },
+            };
+            const result = UserAttributeVerificationActionPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.data).toEqual(payload);
+        });
+        test('should accept payload with phoneNumber attribute', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'user-attribute-verification',
+                user: generateUserId(),
+                attribute: 'phoneNumber',
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = UserAttributeVerificationActionPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.data).toEqual(payload);
+        });
+        test('should accept payload with optional dates', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'user-attribute-verification',
+                user: generateUserId(),
+                attribute: 'email',
+                attempt: 2,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                deletedAt: new Date().toISOString(),
+                deactivatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = UserAttributeVerificationActionPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+        });
+        test('should reject invalid operation', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'invalid-operation',
+                user: generateUserId(),
+                attribute: 'email',
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = UserAttributeVerificationActionPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        test('should reject invalid attribute', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'user-attribute-verification',
+                user: generateUserId(),
+                attribute: 'username',
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = UserAttributeVerificationActionPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        test('should reject missing required fields', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'user-attribute-verification',
+                // missing user, attribute, attempt, etc.
+            };
+            const result = UserAttributeVerificationActionPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        test('should delete undeclared keys', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'user-attribute-verification',
+                user: generateUserId(),
+                attribute: 'email',
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+                extraField: 'should be removed',
+            };
+            const result = UserAttributeVerificationActionPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.data).not.toHaveProperty('extraField');
+        });
+    });
+    describe('UserAttributeVerificationActionRequestSchema', () => {
+        test('should accept empty request', () => {
+            const request = {};
+            const result = UserAttributeVerificationActionRequestSchema.safeParse(request);
+            // Parse succeeds for valid data
+            expect(result.data).toEqual(request);
+        });
+        test('should delete undeclared keys', () => {
+            const request = {
+                extraField: 'should be removed',
+                anotherField: 'also removed',
+            };
+            const result = UserAttributeVerificationActionRequestSchema.safeParse(request);
+            // Parse succeeds for valid data
+            expect(result.data).not.toHaveProperty('extraField');
+            expect(result.data).not.toHaveProperty('anotherField');
+            expect(result.data).toEqual({});
+        });
+    });
+});

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

@@ -1,92 +1,80 @@
-export declare const ActionOperation: {
-    readonly SET_PASSWORD: "set-password";
-    readonly USER_ATTRIBUTE_VERIFICATION: "user-attribute-verification";
-    readonly SIGN_UP: "sign-up";
-    readonly SIGN_UP_VERIFICATION: "sign-up-verification";
-};
-export type AnyActionOperation = (typeof ActionOperation)[keyof typeof ActionOperation];
+import type { z } from 'zod';
 /**
  * Union
  */
-export declare const ActionPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    id: string;
-    attempt: number;
-    expiresAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
-    updatedAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
-    deletedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
-    deactivatedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
-    metadata?: ((In: {
-        [x: string]: string | number | boolean;
-    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/internal/attributes.ts").Out<{
-        [x: string]: string | number | boolean;
-    } | undefined>) | undefined;
-    operation: "set-password";
-    user: string;
-    identifier: "email" | "phoneNumber";
-    policy: {
-        minimumLength: import("arktype/internal/attributes.ts").Default<number, 8>;
-        maximumLength: import("arktype/internal/attributes.ts").Default<number, 36>;
-        minimumCapital: import("arktype/internal/attributes.ts").Default<number, 1>;
-        minimumLower: import("arktype/internal/attributes.ts").Default<number, 1>;
-        minimumNumber: import("arktype/internal/attributes.ts").Default<number, 1>;
-        minimumSpecial: import("arktype/internal/attributes.ts").Default<number, 1>;
-    };
-} | {
-    id: string;
-    attempt: number;
-    expiresAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
-    updatedAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
-    deletedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
-    deactivatedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
-    metadata?: ((In: {
-        [x: string]: string | number | boolean;
-    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/internal/attributes.ts").Out<{
-        [x: string]: string | number | boolean;
-    } | undefined>) | undefined;
-    operation: "sign-up-verification";
-    user: string;
-    identifier: "email" | "phoneNumber";
-} | {
-    id: string;
-    attempt: number;
-    expiresAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
-    updatedAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
-    deletedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
-    deactivatedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
-    metadata?: ((In: {
-        [x: string]: string | number | boolean;
-    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/internal/attributes.ts").Out<{
-        [x: string]: string | number | boolean;
-    } | undefined>) | undefined;
-    operation: "sign-up";
-    user: {
-        givenName?: string | undefined;
-        middleName?: string | undefined;
-        familyName?: string | undefined;
-        honorificPrefix?: string | undefined;
-        honorificSuffix?: string | undefined;
-    };
-    app?: string | undefined;
-} | {
-    id: string;
-    attempt: number;
-    expiresAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
-    updatedAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
-    deletedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
-    deactivatedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
-    metadata?: ((In: {
-        [x: string]: string | number | boolean;
-    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/internal/attributes.ts").Out<{
-        [x: string]: string | number | boolean;
-    } | undefined>) | undefined;
-    operation: "user-attribute-verification";
-    user: string;
-    attribute: "email" | "phoneNumber";
-}, {}>;
-export type ActionPayload = typeof ActionPayloadSchema.inferOut;
-export { ActionIdPropertySchema, ActionIdSchema, type ActionId, type ActionIdProperty, } from './base.js';
+export declare const ActionPayloadSchema: z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
+    operation: z.ZodLiteral<"set-password">;
+    user: z.ZodString;
+    identifier: z.ZodEnum<{
+        email: "email";
+        phoneNumber: "phoneNumber";
+    }>;
+    policy: z.ZodObject<{
+        minimumLength: z.ZodDefault<z.ZodNumber>;
+        maximumLength: z.ZodDefault<z.ZodNumber>;
+        minimumCapital: z.ZodDefault<z.ZodNumber>;
+        minimumLower: z.ZodDefault<z.ZodNumber>;
+        minimumNumber: z.ZodDefault<z.ZodNumber>;
+        minimumSpecial: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    deactivatedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    deletedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    updatedAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    attempt: z.ZodNumber;
+    expiresAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"sign-up-verification">;
+    user: z.ZodString;
+    identifier: z.ZodEnum<{
+        email: "email";
+        phoneNumber: "phoneNumber";
+    }>;
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    deactivatedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    deletedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    updatedAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    attempt: z.ZodNumber;
+    expiresAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    id: z.ZodString;
+}, z.core.$strip>]>, z.ZodObject<{
+    operation: z.ZodLiteral<"sign-up">;
+    app: z.ZodOptional<z.ZodString>;
+    user: z.ZodObject<{
+        givenName: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string | undefined, string | null | undefined>>>;
+        middleName: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string | undefined, string | null | undefined>>>;
+        familyName: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string | undefined, string | null | undefined>>>;
+        honorificPrefix: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string | undefined, string | null | undefined>>>;
+        honorificSuffix: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string | undefined, string | null | undefined>>>;
+    }, z.core.$strip>;
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    deactivatedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    deletedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    updatedAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    attempt: z.ZodNumber;
+    expiresAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    id: z.ZodString;
+}, z.core.$strip>]>, z.ZodObject<{
+    operation: z.ZodLiteral<"user-attribute-verification">;
+    user: z.ZodString;
+    attribute: z.ZodEnum<{
+        email: "email";
+        phoneNumber: "phoneNumber";
+    }>;
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    deactivatedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    deletedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    updatedAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    attempt: z.ZodNumber;
+    expiresAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    id: z.ZodString;
+}, z.core.$strip>]>;
+export type ActionPayload = z.output<typeof ActionPayloadSchema>;
+export { ActionIdPropertySchema, ActionIdSchema, ActionOperation, type ActionId, type ActionIdProperty, type AnyActionOperation, } from './base.js';
 export * from './operations/set-password.js';
 export * from './operations/sign-up-verification.js';
 export * from './operations/sign-up.js';
 export * from './operations/user-attribute-verification.js';
+export * from './utils.js';
 //# sourceMappingURL=schema.d.ts.map

package/dist/esm/action/schema/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/action/schema/schema.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;;;;CAOlB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAC5B,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAImB,CAAC;AACpD,MAAM,MAAM,aAAa,GAAG,OAAO,mBAAmB,CAAC,QAAQ,CAAC;AAEhE,OAAO,EACL,sBAAsB,EACtB,cAAc,EACd,KAAK,QAAQ,EACb,KAAK,gBAAgB,GACtB,MAAM,WAAW,CAAC;AACnB,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,yBAAyB,CAAC;AACxC,cAAc,6CAA6C,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/action/schema/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAO7B;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAImB,CAAC;AACpD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEjE,OAAO,EACL,sBAAsB,EACtB,cAAc,EACd,eAAe,EACf,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,GACxB,MAAM,WAAW,CAAC;AACnB,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,yBAAyB,CAAC;AACxC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,YAAY,CAAC"}

package/dist/esm/action/schema/schema.js

@@ -2,20 +2,15 @@ import { SetPasswordActionPayloadSchema } from './operations/set-password.js';
 import { SignUpVerificationActionPayloadSchema } from './operations/sign-up-verification.js';
 import { SignUpActionPayloadSchema } from './operations/sign-up.js';
 import { UserAttributeVerificationActionPayloadSchema } from './operations/user-attribute-verification.js';
-export const ActionOperation = {
-    SET_PASSWORD: 'set-password',
-    USER_ATTRIBUTE_VERIFICATION: 'user-attribute-verification',
-    SIGN_UP: 'sign-up',
-    SIGN_UP_VERIFICATION: 'sign-up-verification',
-};
 /**
  * Union
  */
 export const ActionPayloadSchema = SetPasswordActionPayloadSchema.or(SignUpVerificationActionPayloadSchema)
     .or(SignUpActionPayloadSchema)
     .or(UserAttributeVerificationActionPayloadSchema);
-export { ActionIdPropertySchema, ActionIdSchema, } from './base.js';
+export { ActionIdPropertySchema, ActionIdSchema, ActionOperation, } from './base.js';
 export * from './operations/set-password.js';
 export * from './operations/sign-up-verification.js';
 export * from './operations/sign-up.js';
 export * from './operations/user-attribute-verification.js';
+export * from './utils.js';

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

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

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

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

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

@@ -0,0 +1,188 @@
+import { describe, expect, test } from 'vitest';
+import { ActionPayloadSchema, ActionOperation } from './schema.js';
+import { generateActionId } from './utils.js';
+import { generateUserId } from '../../customer/schema.js';
+describe('Action Schema - Main', () => {
+    describe('ActionPayloadSchema', () => {
+        test('should accept set-password action payload', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'set-password',
+                user: generateUserId(),
+                identifier: 'email',
+                policy: {},
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { source: 'user-initiated' },
+            };
+            const result = ActionPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+        });
+        test('should accept sign-up-verification action payload', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up-verification',
+                user: generateUserId(),
+                identifier: 'email',
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { method: 'email' },
+            };
+            const result = ActionPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+        });
+        test('should accept sign-up action payload', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up',
+                user: {
+                    firstName: 'John',
+                    lastName: 'Doe',
+                },
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { registration_source: 'web' },
+            };
+            const result = ActionPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+        });
+        test('should accept user-attribute-verification action payload', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'user-attribute-verification',
+                user: generateUserId(),
+                attribute: 'email',
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { verification_type: 'change_email' },
+            };
+            const result = ActionPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+        });
+        test('should reject invalid action operation', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'invalid-operation',
+                metadata: {},
+            };
+            const result = ActionPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        test('should reject payload missing required fields for set-password', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'set-password',
+                // missing password
+                metadata: {},
+            };
+            const result = ActionPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        test('should reject payload missing required fields for sign-up-verification', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up-verification',
+                // missing code
+                metadata: {},
+            };
+            const result = ActionPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        test('should reject payload missing required fields for sign-up', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up',
+                // missing email
+                metadata: {},
+            };
+            const result = ActionPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        test('should reject payload missing required fields for user-attribute-verification', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'user-attribute-verification',
+                attribute: 'email',
+                // missing value and code
+                metadata: {},
+            };
+            const result = ActionPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        test('should accept complex payloads with all optional fields', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up',
+                user: {
+                    firstName: 'John',
+                    lastName: 'Doe',
+                },
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {
+                    source: 'mobile-app',
+                    campaign: 'summer-2024',
+                    referrer: 'friend-invitation',
+                    terms_accepted: true,
+                    marketing_consent: false,
+                },
+            };
+            const result = ActionPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+        });
+        test('should accept user-attribute-verification with phone attribute', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'user-attribute-verification',
+                user: generateUserId(),
+                attribute: 'phoneNumber',
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { verification_method: 'sms' },
+            };
+            const result = ActionPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+        });
+        test('should reject malformed user data in sign-up action', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up',
+                user: 'invalid-user-data', // should be object
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = ActionPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        test('should reject invalid attribute type in user-attribute-verification', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'user-attribute-verification',
+                user: generateUserId(),
+                attribute: 'invalid_attribute',
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = ActionPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('ActionOperation constants', () => {
+        test('should contain expected operation values', () => {
+            expect(ActionOperation.SET_PASSWORD).toBe('set-password');
+            expect(ActionOperation.SIGN_UP_VERIFICATION).toBe('sign-up-verification');
+            expect(ActionOperation.SIGN_UP).toBe('sign-up');
+            expect(ActionOperation.USER_ATTRIBUTE_VERIFICATION).toBe('user-attribute-verification');
+        });
+    });
+});

package/dist/esm/action/schema/utils.d.ts

@@ -0,0 +1,7 @@
+export declare const Model: {
+    readonly Action: {
+        readonly UIDPrefix: "atn";
+    };
+};
+export declare function generateActionId(): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/esm/action/schema/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/action/schema/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;CAIR,CAAC;AAEX,wBAAgB,gBAAgB,WAE/B"}

package/dist/esm/action/schema/utils.js

@@ -0,0 +1,9 @@
+import KSUID from 'ksuid';
+export const Model = {
+    Action: {
+        UIDPrefix: 'atn',
+    },
+};
+export function generateActionId() {
+    return `${Model.Action.UIDPrefix}_${KSUID.randomSync().string}`;
+}

package/dist/esm/action/schema/utils.test.d.ts

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

package/dist/esm/action/schema/utils.test.d.ts.map

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

package/dist/esm/action/schema/utils.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, test } from 'vitest';
+import { Model, generateActionId } from './utils.js';
+describe('Action Schema - Utils', () => {
+    describe('Model constants', () => {
+        test('should have correct UID prefix', () => {
+            expect(Model.Action.UIDPrefix).toBe('atn');
+        });
+    });
+    describe('generateActionId', () => {
+        test('should generate ID with correct prefix', () => {
+            const id = generateActionId();
+            expect(id).toMatch(/^atn_[A-Za-z0-9]+$/);
+        });
+        test('should generate unique IDs', () => {
+            const id1 = generateActionId();
+            const id2 = generateActionId();
+            expect(id1).not.toBe(id2);
+        });
+        test('should generate IDs with correct length', () => {
+            const id = generateActionId();
+            expect(id.length).toBeGreaterThan(4); // prefix + underscore + KSUID
+        });
+    });
+});

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

@@ -1,2 +1,3 @@
+export * from './resources.js';
 export * from './schema/schema.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/activity/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/activity/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/activity/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC"}

package/dist/esm/activity/index.js

@@ -1 +1,2 @@
+export * from './resources.js';
 export * from './schema/schema.js';

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

@@ -0,0 +1,13 @@
+import type { MondoIdentity } from '../common/resources/init.js';
+import { type PaginationCollection } from '../common/schema/collection.js';
+import type { Pagination } from '../common/schema/pagination.js';
+import { type Activity } from './schema/schema.js';
+export declare const PATH = "/v1/activities";
+export declare class ActivityResources {
+    private readonly instance;
+    constructor(instance: MondoIdentity);
+    static buildPath(source: string): string;
+    listItems(source: string, pagination?: Pagination): Promise<PaginationCollection<Activity>>;
+}
+export declare function listActivities(instance: MondoIdentity, source: string, pagination?: Pagination): Promise<PaginationCollection<Activity>>;
+//# sourceMappingURL=resources.d.ts.map

package/dist/esm/activity/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../src/activity/resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAGjE,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,KAAK,QAAQ,EAAkB,MAAM,oBAAoB,CAAC;AAEnE,eAAO,MAAM,IAAI,mBAAmB,CAAC;AAErC,qBAAa,iBAAiB;IACT,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAE3D,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAQjC,SAAS,CACd,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC;CAG3C;AAED,wBAAsB,cAAc,CAClC,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC,CASzC"}