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

package/dist/cjs/activity/schema/base.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseUpdatePayloadSchema = exports.BaseInsertPayloadSchema = exports.BasePayloadSchema = exports.BaseSchema = exports.PerformedBySchema = exports.SourceSchema = exports.ActivityIdPropertySchema = exports.ActivityIdSchema = exports.PerformerType = exports.ActivityType = void 0;
+const arktype_1 = require("arktype");
+const schema_js_1 = require("../../app/schema.js");
+const index_js_1 = require("../../common/index.js");
+const id_js_1 = require("../../common/schema/id.js");
+const metadata_js_1 = require("../../common/schema/metadata.js");
+const utils_js_1 = require("./utils.js");
+exports.ActivityType = {
+    UNKNOWN: 'unknown',
+    NOTE: 'note',
+    OPERATION: 'operation',
+    AUTHORIZATION: 'authorization',
+    AUTHENTICATION: 'authentication',
+};
+exports.PerformerType = {
+    SYSTEM: 'system',
+    GUEST: 'guest',
+    IDENTITY: 'identity',
+    AUTOMATION: 'automation',
+    INTEGRATION: 'integration',
+};
+exports.ActivityIdSchema = (0, id_js_1.KSUIDSchema)(utils_js_1.Model.Activity.UIDPrefix);
+exports.ActivityIdPropertySchema = (0, arktype_1.type)({
+    id: exports.ActivityIdSchema,
+});
+exports.SourceSchema = (0, arktype_1.type)('string');
+exports.PerformedBySchema = (0, arktype_1.type)({
+    type: arktype_1.type.enumerated(exports.PerformerType.SYSTEM, exports.PerformerType.GUEST, exports.PerformerType.IDENTITY, exports.PerformerType.AUTOMATION, exports.PerformerType.INTEGRATION),
+    identifier: (0, arktype_1.type)('string'),
+});
+const CommonSchema = (0, arktype_1.type)({
+    id: exports.ActivityIdSchema,
+    performedBy: exports.PerformedBySchema,
+    source: exports.SourceSchema,
+    app: schema_js_1.AppIdSchema.optional(),
+    isMutateable: (0, arktype_1.type)('boolean'),
+});
+exports.BaseSchema = CommonSchema.and({
+    createdAt: index_js_1.RequiredDateSchema,
+    updatedAt: index_js_1.RequiredDateSchema,
+    deletedAt: index_js_1.OptionalDateSchema.optional(),
+    deactivatedAt: index_js_1.OptionalDateSchema.optional(),
+}).and(metadata_js_1.MetadataMapPropertySchema);
+exports.BasePayloadSchema = CommonSchema.and({
+    createdAt: index_js_1.RequiredDatePayloadSchema,
+    updatedAt: index_js_1.RequiredDatePayloadSchema,
+    'deletedAt?': index_js_1.OptionalDatePayloadSchema,
+    'deactivatedAt?': index_js_1.OptionalDatePayloadSchema,
+}).and(metadata_js_1.MetadataPayloadPropertySchema);
+exports.BaseInsertPayloadSchema = (0, arktype_1.type)({
+    id: exports.ActivityIdSchema.default(() => (0, utils_js_1.generateActivityId)()),
+    performedBy: exports.PerformedBySchema.optional(),
+}).and(metadata_js_1.UpsertMetadataPropertyPayloadSchema);
+exports.BaseUpdatePayloadSchema = (0, arktype_1.type)({
+    performedBy: exports.PerformedBySchema.optional(),
+}).and(metadata_js_1.UpsertMetadataPropertyPayloadSchema);

package/dist/cjs/activity/schema/base.test.d.ts

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

package/dist/cjs/activity/schema/base.test.d.ts.map

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

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

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const arktype_1 = require("arktype");
+const vitest_1 = require("vitest");
+const utils_js_1 = require("../../app/utils.js");
+const base_js_1 = require("./base.js");
+const utils_js_2 = require("./utils.js");
+(0, vitest_1.describe)('Activity Schema - Base', () => {
+    (0, vitest_1.describe)('ActivityType constants', () => {
+        (0, vitest_1.test)('should have correct activity type values', () => {
+            (0, vitest_1.expect)(base_js_1.ActivityType.UNKNOWN).toBe('unknown');
+            (0, vitest_1.expect)(base_js_1.ActivityType.NOTE).toBe('note');
+            (0, vitest_1.expect)(base_js_1.ActivityType.OPERATION).toBe('operation');
+            (0, vitest_1.expect)(base_js_1.ActivityType.AUTHORIZATION).toBe('authorization');
+            (0, vitest_1.expect)(base_js_1.ActivityType.AUTHENTICATION).toBe('authentication');
+        });
+    });
+    (0, vitest_1.describe)('PerformerType constants', () => {
+        (0, vitest_1.test)('should have correct performer type values', () => {
+            (0, vitest_1.expect)(base_js_1.PerformerType.SYSTEM).toBe('system');
+            (0, vitest_1.expect)(base_js_1.PerformerType.GUEST).toBe('guest');
+            (0, vitest_1.expect)(base_js_1.PerformerType.IDENTITY).toBe('identity');
+            (0, vitest_1.expect)(base_js_1.PerformerType.AUTOMATION).toBe('automation');
+            (0, vitest_1.expect)(base_js_1.PerformerType.INTEGRATION).toBe('integration');
+        });
+    });
+    (0, vitest_1.describe)('ActivityIdSchema', () => {
+        (0, vitest_1.test)('should accept valid activity ID', () => {
+            const id = (0, utils_js_2.generateActivityId)();
+            const result = (0, base_js_1.ActivityIdSchema)(id);
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result).toBe(id);
+        });
+        (0, vitest_1.test)('should reject invalid activity ID format', () => {
+            (0, vitest_1.expect)((0, base_js_1.ActivityIdSchema)('invalid_id')).toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)((0, base_js_1.ActivityIdSchema)('wrong_prefix_123')).toBeInstanceOf(arktype_1.type.errors);
+        });
+        (0, vitest_1.test)('should reject non-string values', () => {
+            (0, vitest_1.expect)((0, base_js_1.ActivityIdSchema)(123)).toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)((0, base_js_1.ActivityIdSchema)(null)).toBeInstanceOf(arktype_1.type.errors);
+        });
+    });
+    (0, vitest_1.describe)('ActivityIdPropertySchema', () => {
+        (0, vitest_1.test)('should accept valid id property', () => {
+            const payload = { id: (0, utils_js_2.generateActivityId)() };
+            const result = (0, base_js_1.ActivityIdPropertySchema)(payload);
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result).toEqual(payload);
+        });
+        (0, vitest_1.test)('should reject missing id', () => {
+            const result = (0, base_js_1.ActivityIdPropertySchema)({});
+            (0, vitest_1.expect)(result).toBeInstanceOf(arktype_1.type.errors);
+        });
+    });
+    (0, vitest_1.describe)('SourceSchema', () => {
+        (0, vitest_1.test)('should accept string source', () => {
+            const result = (0, base_js_1.SourceSchema)('api-request');
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result).toBe('api-request');
+        });
+        (0, vitest_1.test)('should reject non-string values', () => {
+            (0, vitest_1.expect)((0, base_js_1.SourceSchema)(123)).toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)((0, base_js_1.SourceSchema)(null)).toBeInstanceOf(arktype_1.type.errors);
+        });
+    });
+    (0, vitest_1.describe)('PerformedBySchema', () => {
+        (0, vitest_1.test)('should accept valid performer with system type', () => {
+            const performer = {
+                type: 'system',
+                identifier: 'system-process',
+            };
+            const result = (0, base_js_1.PerformedBySchema)(performer);
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result).toEqual(performer);
+        });
+        (0, vitest_1.test)('should accept valid performer with identity type', () => {
+            const performer = {
+                type: 'identity',
+                identifier: 'user@example.com',
+            };
+            const result = (0, base_js_1.PerformedBySchema)(performer);
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result).toEqual(performer);
+        });
+        (0, vitest_1.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 = (0, base_js_1.PerformedBySchema)(performer);
+                (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            }
+        });
+        (0, vitest_1.test)('should reject invalid performer type', () => {
+            const performer = {
+                type: 'invalid',
+                identifier: 'test',
+            };
+            const result = (0, base_js_1.PerformedBySchema)(performer);
+            (0, vitest_1.expect)(result).toBeInstanceOf(arktype_1.type.errors);
+        });
+        (0, vitest_1.test)('should reject missing fields', () => {
+            (0, vitest_1.expect)((0, base_js_1.PerformedBySchema)({ type: 'system' })).toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)((0, base_js_1.PerformedBySchema)({ identifier: 'test' })).toBeInstanceOf(arktype_1.type.errors);
+        });
+    });
+    (0, vitest_1.describe)('BaseSchema', () => {
+        (0, vitest_1.test)('should accept complete base activity', () => {
+            const activity = {
+                id: (0, utils_js_2.generateActivityId)(),
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user@example.com',
+                },
+                source: 'web-app',
+                app: (0, utils_js_1.generateAppId)(),
+                isMutateable: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: { key: 'value' },
+            };
+            const result = (0, base_js_1.BaseSchema)(activity);
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+        });
+        (0, vitest_1.test)('should accept activity without app', () => {
+            const activity = {
+                id: (0, utils_js_2.generateActivityId)(),
+                performedBy: {
+                    type: 'system',
+                    identifier: 'background-job',
+                },
+                source: 'cron',
+                isMutateable: false,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = (0, base_js_1.BaseSchema)(activity);
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+        });
+        (0, vitest_1.test)('should accept activity with optional dates', () => {
+            const activity = {
+                id: (0, utils_js_2.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 = (0, base_js_1.BaseSchema)(activity);
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+        });
+        (0, vitest_1.test)('should reject missing required fields', () => {
+            const activity = {
+                id: (0, utils_js_2.generateActivityId)(),
+                performedBy: {
+                    type: 'system',
+                    identifier: 'test',
+                },
+                // missing source, isMutateable, dates, metadata
+            };
+            const result = (0, base_js_1.BaseSchema)(activity);
+            (0, vitest_1.expect)(result).toBeInstanceOf(arktype_1.type.errors);
+        });
+    });
+    (0, vitest_1.describe)('BaseInsertPayloadSchema', () => {
+        (0, vitest_1.test)('should accept complete insert payload', () => {
+            const payload = {
+                id: (0, utils_js_2.generateActivityId)(),
+                performedBy: {
+                    type: 'identity',
+                    identifier: 'user123',
+                },
+                metadata: { source: 'api' },
+            };
+            const result = (0, base_js_1.BaseInsertPayloadSchema)(payload);
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+        });
+        (0, vitest_1.test)('should accept minimal insert payload', () => {
+            const payload = {};
+            const result = (0, base_js_1.BaseInsertPayloadSchema)(payload);
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            // Should generate default ID
+            (0, vitest_1.expect)(result.id).toMatch(/^act_/);
+        });
+        (0, vitest_1.test)('should generate default ID when not provided', () => {
+            const payload = {
+                performedBy: {
+                    type: 'system',
+                    identifier: 'auto-process',
+                },
+            };
+            const result = (0, base_js_1.BaseInsertPayloadSchema)(payload);
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result.id).toMatch(/^act_/);
+        });
+    });
+    (0, vitest_1.describe)('BaseUpdatePayloadSchema', () => {
+        (0, vitest_1.test)('should accept update with performer', () => {
+            const payload = {
+                performedBy: {
+                    type: 'automation',
+                    identifier: 'scheduled-task',
+                },
+                metadata: { updated: true },
+            };
+            const result = (0, base_js_1.BaseUpdatePayloadSchema)(payload);
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result).toEqual(payload);
+        });
+        (0, vitest_1.test)('should accept empty update payload', () => {
+            const payload = {};
+            const result = (0, base_js_1.BaseUpdatePayloadSchema)(payload);
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+            (0, vitest_1.expect)(result).toEqual(payload);
+        });
+        (0, vitest_1.test)('should accept update with only metadata', () => {
+            const payload = {
+                metadata: { version: '2.0' },
+            };
+            const result = (0, base_js_1.BaseUpdatePayloadSchema)(payload);
+            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
+        });
+    });
+});

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

@@ -0,0 +1,235 @@
+export { ActivityType, PerformerType, type AnyActivityType, type AnyPerformerType, } from './base.js';
+export declare const ActivitySchema: import("arktype/out/methods/object.js").ObjectType<{
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    app?: string | undefined;
+    createdAt: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>);
+    updatedAt: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>);
+    deletedAt?: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>) | undefined;
+    deactivatedAt?: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>) | undefined;
+    metadata: (In: import("arktype/out/attributes.js").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
+    type: "authentication";
+    status: "success" | "fail";
+    identity: string;
+    message: string;
+} | {
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    app?: string | undefined;
+    createdAt: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>);
+    updatedAt: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>);
+    deletedAt?: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>) | undefined;
+    deactivatedAt?: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>) | undefined;
+    metadata: (In: import("arktype/out/attributes.js").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
+    type: "authorization";
+    status: "success" | "fail";
+    message: string;
+    identity?: string | undefined;
+} | {
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    app?: string | undefined;
+    createdAt: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>);
+    updatedAt: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>);
+    deletedAt?: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>) | undefined;
+    deactivatedAt?: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>) | undefined;
+    metadata: (In: import("arktype/out/attributes.js").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
+    type: "note";
+    message: string;
+} | {
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    app?: string | undefined;
+    createdAt: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>);
+    updatedAt: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>);
+    deletedAt?: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>) | undefined;
+    deactivatedAt?: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>) | undefined;
+    metadata: (In: import("arktype/out/attributes.js").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
+    type: "operation";
+    operation: "delete" | "automation" | "create" | "update";
+    message: string;
+    target: string;
+} | {
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    app?: string | undefined;
+    createdAt: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>);
+    updatedAt: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>);
+    deletedAt?: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>) | undefined;
+    deactivatedAt?: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>) | undefined;
+    metadata: (In: import("arktype/out/attributes.js").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
+    type: "unknown";
+    message: string;
+}, {}>;
+export type ActivityProperties = typeof ActivitySchema.inferIn;
+export type Activity = typeof ActivitySchema.inferOut;
+export declare const ActivityPayloadSchema: import("arktype/out/methods/object.js").ObjectType<{
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    app?: string | undefined;
+    createdAt: (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;
+    type: "authentication";
+    status: "success" | "fail";
+    identity: string;
+    message: string;
+} | {
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    app?: string | undefined;
+    createdAt: (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;
+    type: "authorization";
+    status: "success" | "fail";
+    message: string;
+    identity?: string | undefined;
+} | {
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    app?: string | undefined;
+    createdAt: (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;
+    type: "note";
+    message: string;
+} | {
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    app?: string | undefined;
+    createdAt: (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;
+    type: "operation";
+    operation: "delete" | "automation" | "create" | "update";
+    message: string;
+    target: string;
+} | {
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    app?: string | undefined;
+    createdAt: (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;
+    type: "unknown";
+    message: string;
+}, {}>;
+export type ActivityPayload = typeof ActivityPayloadSchema.inferOut;
+export declare const InsertActivityPayloadSchema: import("arktype/out/methods/object.js").ObjectType<{
+    id: import("arktype/out/attributes.js").Default<string, string>;
+    performedBy?: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    } | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | null>) | undefined;
+    type: "note";
+    message: string;
+}, {}>;
+export type InsertActivityPayload = typeof InsertActivityPayloadSchema.inferOut;
+export declare const UpdateActivityPayloadSchema: import("arktype/out/methods/object.js").ObjectType<{
+    performedBy?: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    } | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | null>) | undefined;
+    type: "note";
+    message?: string | undefined;
+}, {}>;
+export type UpdateActivityPayload = typeof UpdateActivityPayloadSchema.inferOut;
+export { ActivityIdPropertySchema, ActivityIdSchema, PerformedBySchema, SourceSchema, type ActivityId, type ActivityIdProperty, type PerformedBy, } from './base.js';
+export * from './types/authentication.js';
+export * from './types/authorization.js';
+export * from './types/note.js';
+export * from './types/operation.js';
+export * from './types/unknown.js';
+export * from './utils.js';
+//# sourceMappingURL=schema.d.ts.map

package/dist/cjs/activity/schema/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/activity/schema/schema.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACtB,MAAM,WAAW,CAAC;AAEnB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAKC,CAAC;AAC7B,MAAM,MAAM,kBAAkB,GAAG,OAAO,cAAc,CAAC,OAAO,CAAC;AAC/D,MAAM,MAAM,QAAQ,GAAG,OAAO,cAAc,CAAC,QAAQ,CAAC;AAEtD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAKC,CAAC;AACpC,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,QAAQ,CAAC;AAEpE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;MAAkC,CAAC;AAC3E,MAAM,MAAM,qBAAqB,GAAG,OAAO,2BAA2B,CAAC,QAAQ,CAAC;AAEhF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;MAAkC,CAAC;AAC3E,MAAM,MAAM,qBAAqB,GAAG,OAAO,2BAA2B,CAAC,QAAQ,CAAC;AAEhF,OAAO,EACL,wBAAwB,EACxB,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,WAAW,GACjB,MAAM,WAAW,CAAC;AACnB,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AAEnC,cAAc,YAAY,CAAC"}

package/dist/cjs/activity/schema/schema.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceSchema = exports.PerformedBySchema = exports.ActivityIdSchema = exports.ActivityIdPropertySchema = exports.UpdateActivityPayloadSchema = exports.InsertActivityPayloadSchema = exports.ActivityPayloadSchema = exports.ActivitySchema = exports.PerformerType = exports.ActivityType = void 0;
+const authentication_js_1 = require("./types/authentication.js");
+const authorization_js_1 = require("./types/authorization.js");
+const note_js_1 = require("./types/note.js");
+const operation_js_1 = require("./types/operation.js");
+const unknown_js_1 = require("./types/unknown.js");
+var base_js_1 = require("./base.js");
+Object.defineProperty(exports, "ActivityType", { enumerable: true, get: function () { return base_js_1.ActivityType; } });
+Object.defineProperty(exports, "PerformerType", { enumerable: true, get: function () { return base_js_1.PerformerType; } });
+exports.ActivitySchema = note_js_1.NoteActivitySchema.or(authentication_js_1.AuthenticationActivitySchema)
+    .or(authorization_js_1.AuthorizationActivitySchema)
+    .or(operation_js_1.OperationActivitySchema)
+    .or(unknown_js_1.UnknownActivitySchema);
+exports.ActivityPayloadSchema = note_js_1.NoteActivityPayloadSchema.or(authentication_js_1.AuthenticationActivityPayloadSchema)
+    .or(authorization_js_1.AuthorizationActivityPayloadSchema)
+    .or(operation_js_1.OperationActivityPayloadSchema)
+    .or(unknown_js_1.UnknownActivityPayloadSchema);
+exports.InsertActivityPayloadSchema = note_js_1.InsertNoteActivityPayloadSchema;
+exports.UpdateActivityPayloadSchema = note_js_1.UpdateNoteActivityPayloadSchema;
+var base_js_2 = require("./base.js");
+Object.defineProperty(exports, "ActivityIdPropertySchema", { enumerable: true, get: function () { return base_js_2.ActivityIdPropertySchema; } });
+Object.defineProperty(exports, "ActivityIdSchema", { enumerable: true, get: function () { return base_js_2.ActivityIdSchema; } });
+Object.defineProperty(exports, "PerformedBySchema", { enumerable: true, get: function () { return base_js_2.PerformedBySchema; } });
+Object.defineProperty(exports, "SourceSchema", { enumerable: true, get: function () { return base_js_2.SourceSchema; } });
+__exportStar(require("./types/authentication.js"), exports);
+__exportStar(require("./types/authorization.js"), exports);
+__exportStar(require("./types/note.js"), exports);
+__exportStar(require("./types/operation.js"), exports);
+__exportStar(require("./types/unknown.js"), exports);
+__exportStar(require("./utils.js"), exports);

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

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

package/dist/cjs/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":""}