@go-mondo/identity-sdk 0.0.1 → 0.0.2-beta.12

package/dist/esm/action/schema/operations/set-password.test.js

@@ -0,0 +1,165 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateUserId } from '../../../customer/schema.js';
+import { generateActionId } from '../utils.js';
+import { SetPasswordActionPayloadSchema, SetPasswordActionRequestSchema, } from './set-password.js';
+describe('Action Schema Operations - Set Password', () => {
+    describe('SetPasswordActionPayloadSchema', () => {
+        test('should accept complete payload with email identifier', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'set-password',
+                user: generateUserId(),
+                identifier: 'email',
+                policy: {},
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { key: 'value' },
+            };
+            const result = SetPasswordActionPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            // Policy defaults are applied, so we don't compare exact equality
+        });
+        test('should accept payload with phoneNumber identifier', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'set-password',
+                user: generateUserId(),
+                identifier: 'phoneNumber',
+                policy: {},
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = SetPasswordActionPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            // Policy defaults are applied, so we don't compare exact equality
+        });
+        test('should accept payload with optional dates', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'set-password',
+                user: generateUserId(),
+                identifier: 'email',
+                policy: {},
+                attempt: 2,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                deletedAt: new Date().toISOString(),
+                deactivatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = SetPasswordActionPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid operation', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'invalid-operation',
+                user: generateUserId(),
+                identifier: 'email',
+                policy: {},
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = SetPasswordActionPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid identifier', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'set-password',
+                user: generateUserId(),
+                identifier: 'username',
+                policy: {},
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = SetPasswordActionPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject missing required fields', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'set-password',
+                // missing user, identifier, policy, etc.
+            };
+            const result = SetPasswordActionPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should delete undeclared keys', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'set-password',
+                user: generateUserId(),
+                identifier: 'email',
+                policy: {},
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+                extraField: 'should be removed',
+            };
+            const result = SetPasswordActionPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).not.toHaveProperty('extraField');
+        });
+    });
+    describe('SetPasswordActionRequestSchema', () => {
+        test('should accept valid request', () => {
+            const request = {
+                code: 'reset_code_123',
+                password: 'NewPassword123!',
+            };
+            const result = SetPasswordActionRequestSchema(request);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(request);
+        });
+        test('should reject missing code', () => {
+            const request = {
+                password: 'NewPassword123!',
+            };
+            const result = SetPasswordActionRequestSchema(request);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject missing password', () => {
+            const request = {
+                code: 'reset_code_123',
+            };
+            const result = SetPasswordActionRequestSchema(request);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject non-string values', () => {
+            const request1 = {
+                code: 123456,
+                password: 'NewPassword123!',
+            };
+            const request2 = {
+                code: 'reset_code_123',
+                password: 123456,
+            };
+            expect(SetPasswordActionRequestSchema(request1)).toBeInstanceOf(type.errors);
+            expect(SetPasswordActionRequestSchema(request2)).toBeInstanceOf(type.errors);
+        });
+        test('should delete undeclared keys', () => {
+            const request = {
+                code: 'reset_code_123',
+                password: 'NewPassword123!',
+                extraField: 'should be removed',
+            };
+            const result = SetPasswordActionRequestSchema(request);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).not.toHaveProperty('extraField');
+            expect(result).toEqual({
+                code: 'reset_code_123',
+                password: 'NewPassword123!',
+            });
+        });
+    });
+});

package/dist/esm/action/schema/operations/sign-up-verification.d.ts

@@ -0,0 +1,22 @@
+export declare const SignUpVerificationActionPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    attempt: number;
+    expiresAt: (In: string | Date) => import("arktype").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype").Out<string>;
+    deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    operation: "sign-up-verification";
+    user: string;
+    identifier: "email" | "phoneNumber";
+}, {}>;
+export type SignUpVerificationActionPayload = typeof SignUpVerificationActionPayloadSchema.inferOut;
+export declare const SignUpVerificationActionRequestSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    code: string;
+}, {}>;
+export type SignUpVerificationActionRequest = typeof SignUpVerificationActionRequestSchema.inferOut;
+//# sourceMappingURL=sign-up-verification.d.ts.map

package/dist/esm/action/schema/operations/sign-up-verification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sign-up-verification.d.ts","sourceRoot":"","sources":["../../../../../src/action/schema/operations/sign-up-verification.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;MAItB,CAAC;AAC7B,MAAM,MAAM,+BAA+B,GACzC,OAAO,qCAAqC,CAAC,QAAQ,CAAC;AAExD,eAAO,MAAM,qCAAqC;;MAEtB,CAAC;AAC7B,MAAM,MAAM,+BAA+B,GACzC,OAAO,qCAAqC,CAAC,QAAQ,CAAC"}

package/dist/esm/action/schema/operations/sign-up-verification.js

@@ -0,0 +1,12 @@
+import { type } from 'arktype';
+import { UserIdSchema } from '../../../customer/schema.js';
+import { IdentityIdentifierSchema } from '../../../identity/schema.js';
+import { BasePayloadSchema } from '../base.js';
+export const SignUpVerificationActionPayloadSchema = BasePayloadSchema.and({
+    operation: type("'sign-up-verification'"),
+    user: UserIdSchema,
+    identifier: IdentityIdentifierSchema,
+}).onUndeclaredKey('delete');
+export const SignUpVerificationActionRequestSchema = type({
+    code: type('string'),
+}).onUndeclaredKey('delete');

package/dist/esm/action/schema/operations/sign-up-verification.test.d.ts

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

package/dist/esm/action/schema/operations/sign-up-verification.test.d.ts.map

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

package/dist/esm/action/schema/operations/sign-up-verification.test.js

@@ -0,0 +1,139 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateUserId } from '../../../customer/schema.js';
+import { generateActionId } from '../utils.js';
+import { SignUpVerificationActionPayloadSchema, SignUpVerificationActionRequestSchema, } from './sign-up-verification.js';
+describe('Action Schema Operations - Sign Up Verification', () => {
+    describe('SignUpVerificationActionPayloadSchema', () => {
+        test('should accept complete payload', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up-verification',
+                user: generateUserId(),
+                identifier: 'email',
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { key: 'value' },
+            };
+            const result = SignUpVerificationActionPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept phoneNumber identifier', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up-verification',
+                user: generateUserId(),
+                identifier: 'phoneNumber',
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = SignUpVerificationActionPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept payload with optional dates', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up-verification',
+                user: generateUserId(),
+                identifier: 'email',
+                attempt: 2,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                deletedAt: new Date().toISOString(),
+                deactivatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = SignUpVerificationActionPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid operation', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'invalid-operation',
+                user: generateUserId(),
+                identifier: 'email',
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = SignUpVerificationActionPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid identifier', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up-verification',
+                user: generateUserId(),
+                identifier: 'username',
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = SignUpVerificationActionPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject missing required fields', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up-verification',
+                // missing user, identifier, etc.
+            };
+            const result = SignUpVerificationActionPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should delete undeclared keys', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up-verification',
+                user: generateUserId(),
+                identifier: 'email',
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+                extraField: 'should be removed',
+            };
+            const result = SignUpVerificationActionPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).not.toHaveProperty('extraField');
+        });
+    });
+    describe('SignUpVerificationActionRequestSchema', () => {
+        test('should accept valid request', () => {
+            const request = {
+                code: 'verification_code_123',
+            };
+            const result = SignUpVerificationActionRequestSchema(request);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(request);
+        });
+        test('should reject missing code', () => {
+            const result = SignUpVerificationActionRequestSchema({});
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject non-string code', () => {
+            const request = {
+                code: 123456,
+            };
+            const result = SignUpVerificationActionRequestSchema(request);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should delete undeclared keys', () => {
+            const request = {
+                code: 'verification_code_123',
+                extraField: 'should be removed',
+            };
+            const result = SignUpVerificationActionRequestSchema(request);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).not.toHaveProperty('extraField');
+            expect(result).toEqual({ code: 'verification_code_123' });
+        });
+    });
+});

package/dist/esm/action/schema/operations/sign-up.d.ts

@@ -0,0 +1,44 @@
+export declare const SignUpActionPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    attempt: number;
+    expiresAt: (In: string | Date) => import("arktype").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype").Out<string>;
+    deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").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;
+}, {}>;
+export type SignUpActionPayload = typeof SignUpActionPayloadSchema.inferOut;
+export declare const SignUpActionRequestSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    givenName?: string | undefined;
+    middleName?: string | undefined;
+    familyName?: string | undefined;
+    honorificPrefix?: string | undefined;
+    honorificSuffix?: string | undefined;
+    email: string;
+    phoneNumber?: string | undefined;
+    id?: string | undefined;
+} | {
+    givenName?: string | undefined;
+    middleName?: string | undefined;
+    familyName?: string | undefined;
+    honorificPrefix?: string | undefined;
+    honorificSuffix?: string | undefined;
+    phoneNumber: string;
+    email?: string | undefined;
+    id?: string | undefined;
+}, {}>;
+export type SignUpActionRequest = typeof SignUpActionRequestSchema.inferOut;
+//# sourceMappingURL=sign-up.d.ts.map

package/dist/esm/action/schema/operations/sign-up.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sign-up.d.ts","sourceRoot":"","sources":["../../../../../src/action/schema/operations/sign-up.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;MAIV,CAAC;AAC7B,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAY5E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;MAErC,CAAC;AACF,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC"}

package/dist/esm/action/schema/operations/sign-up.js

@@ -0,0 +1,18 @@
+import { type } from 'arktype';
+import { AppIdSchema } from '../../../app/schema.js';
+import { InsertUserPayloadSchema, RequiredEmailSchema, RequiredPhoneNumberSchema, UserNamePropertiesSchema, } from '../../../customer/users/schema.js';
+import { BasePayloadSchema } from '../base.js';
+export const SignUpActionPayloadSchema = BasePayloadSchema.and({
+    operation: type("'sign-up'"),
+    app: AppIdSchema.optional(),
+    user: UserNamePropertiesSchema,
+}).onUndeclaredKey('delete');
+const EmailSignUpActionRequestSchema = UserNamePropertiesSchema.and({
+    email: RequiredEmailSchema,
+    phoneNumber: RequiredPhoneNumberSchema.optional(),
+}).and(InsertUserPayloadSchema.pick('id'));
+const PhoneNumberSignUpActionRequestSchema = UserNamePropertiesSchema.and({
+    phoneNumber: RequiredPhoneNumberSchema,
+    email: RequiredEmailSchema.optional(),
+}).and(InsertUserPayloadSchema.pick('id'));
+export const SignUpActionRequestSchema = EmailSignUpActionRequestSchema.or(PhoneNumberSignUpActionRequestSchema);

package/dist/esm/action/schema/operations/sign-up.test.d.ts

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

package/dist/esm/action/schema/operations/sign-up.test.d.ts.map

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

package/dist/esm/action/schema/operations/sign-up.test.js

@@ -0,0 +1,172 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateAppId } from '../../../app/utils.js';
+import { generateUserId } from '../../../customer/schema.js';
+import { generateActionId } from '../utils.js';
+import { SignUpActionPayloadSchema, SignUpActionRequestSchema, } from './sign-up.js';
+describe('Action Schema Operations - Sign Up', () => {
+    describe('SignUpActionPayloadSchema', () => {
+        test('should accept complete payload with app', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up',
+                app: generateAppId(),
+                user: {
+                    givenName: 'John',
+                    familyName: 'Doe',
+                },
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { key: 'value' },
+            };
+            const result = SignUpActionPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept payload without app', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up',
+                user: {
+                    givenName: 'Jane',
+                    familyName: 'Smith',
+                },
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = SignUpActionPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept minimal user name properties', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up',
+                user: {},
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = SignUpActionPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid operation', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'invalid-operation',
+                user: { givenName: 'John' },
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = SignUpActionPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject missing required fields', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up',
+                // missing user, attempt, etc.
+            };
+            const result = SignUpActionPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should delete undeclared keys', () => {
+            const payload = {
+                id: generateActionId(),
+                operation: 'sign-up',
+                user: { givenName: 'John' },
+                attempt: 1,
+                expiresAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+                extraField: 'should be removed',
+            };
+            const result = SignUpActionPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).not.toHaveProperty('extraField');
+        });
+    });
+    describe('SignUpActionRequestSchema', () => {
+        test('should accept email sign up request', () => {
+            const request = {
+                id: generateUserId(),
+                email: 'john@example.com',
+                givenName: 'John',
+                familyName: 'Doe',
+            };
+            const result = SignUpActionRequestSchema(request);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(request);
+        });
+        test('should accept phone number sign up request', () => {
+            const request = {
+                id: generateUserId(),
+                phoneNumber: '+1234567890',
+                givenName: 'Jane',
+                familyName: 'Smith',
+            };
+            const result = SignUpActionRequestSchema(request);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(request);
+        });
+        test('should accept request with both email and phone', () => {
+            const request = {
+                id: generateUserId(),
+                email: 'john@example.com',
+                phoneNumber: '+1234567890',
+                givenName: 'John',
+                familyName: 'Doe',
+            };
+            const result = SignUpActionRequestSchema(request);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(request);
+        });
+        test('should accept minimal request with just email', () => {
+            const request = {
+                email: 'minimal@example.com',
+            };
+            const result = SignUpActionRequestSchema(request);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept minimal request with just phone', () => {
+            const request = {
+                phoneNumber: '+1234567890',
+            };
+            const result = SignUpActionRequestSchema(request);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject request without email or phone', () => {
+            const request = {
+                givenName: 'John',
+                familyName: 'Doe',
+            };
+            const result = SignUpActionRequestSchema(request);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid email format', () => {
+            const request = {
+                email: 'invalid-email',
+                givenName: 'John',
+            };
+            const result = SignUpActionRequestSchema(request);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should accept optional name properties', () => {
+            const request = {
+                email: 'john@example.com',
+                givenName: 'John',
+                familyName: 'Doe',
+                middleName: 'Michael',
+                honorificPrefix: 'Dr.',
+                honorificSuffix: 'Jr.',
+            };
+            const result = SignUpActionRequestSchema(request);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+    });
+});

package/dist/esm/action/schema/operations/user-attribute-verification.d.ts

@@ -0,0 +1,20 @@
+export declare const UserAttributeVerificationActionPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    attempt: number;
+    expiresAt: (In: string | Date) => import("arktype").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype").Out<string>;
+    deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    operation: "user-attribute-verification";
+    user: string;
+    attribute: "email" | "phoneNumber";
+}, {}>;
+export type UserAttributeVerificationActionPayload = typeof UserAttributeVerificationActionPayloadSchema.inferOut;
+export declare const UserAttributeVerificationActionRequestSchema: import("arktype/internal/methods/object.ts").ObjectType<object, {}>;
+export type UserAttributeVerificationActionRequest = typeof UserAttributeVerificationActionRequestSchema.inferOut;
+//# sourceMappingURL=user-attribute-verification.d.ts.map

package/dist/esm/action/schema/operations/user-attribute-verification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-attribute-verification.d.ts","sourceRoot":"","sources":["../../../../../src/action/schema/operations/user-attribute-verification.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;MAK3B,CAAC;AAC/B,MAAM,MAAM,sCAAsC,GAChD,OAAO,4CAA4C,CAAC,QAAQ,CAAC;AAE/D,eAAO,MAAM,4CAA4C,qEAE9B,CAAC;AAC5B,MAAM,MAAM,sCAAsC,GAChD,OAAO,4CAA4C,CAAC,QAAQ,CAAC"}

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

@@ -0,0 +1,10 @@
+import { type } from 'arktype';
+import { UserIdSchema } from '../../../customer/schema.js';
+import { IdentityIdentifierSchema } from '../../../identity/schema.js';
+import { BasePayloadSchema } from '../base.js';
+export const UserAttributeVerificationActionPayloadSchema = BasePayloadSchema.and({
+    operation: type("'user-attribute-verification'"),
+    user: UserIdSchema,
+    attribute: IdentityIdentifierSchema,
+}).onUndeclaredKey('delete');
+export const UserAttributeVerificationActionRequestSchema = type({}).onUndeclaredKey('delete');

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

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

package/dist/esm/action/schema/operations/user-attribute-verification.test.d.ts.map

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