@go-mondo/identity-sdk 0.0.1-beta.2

package/lib/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/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;
+}, {}>;
+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: import("arktype/internal/attributes.ts").Default<string, string>;
+} | {
+    givenName?: string | undefined;
+    middleName?: string | undefined;
+    familyName?: string | undefined;
+    honorificPrefix?: string | undefined;
+    honorificSuffix?: string | undefined;
+    phoneNumber: string;
+    email?: string | undefined;
+    id: import("arktype/internal/attributes.ts").Default<string, string>;
+}, {}>;
+export type SignUpActionRequest = typeof SignUpActionRequestSchema.inferOut;
+//# sourceMappingURL=sign-up.d.ts.map

package/lib/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/lib/esm/action/schema/operations/sign-up.js

@@ -0,0 +1,18 @@
+import { type } from 'arktype';
+import { AppIdSchema } from '../../../app/schema/app.js';
+import { InsertUserPayloadSchema, RequiredEmailSchema, RequiredPhoneNumberSchema, UserNamePropertiesSchema, } from '../../../customer/schema/user.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/lib/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/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 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/lib/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/lib/esm/action/schema/operations/user-attribute-verification.js

@@ -0,0 +1,10 @@
+import { type } from 'arktype';
+import { UserIdSchema } from '../../../customer/schema/user.js';
+import { IdentityIdentifierSchema } from '../../../identity/schema/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/lib/esm/action/schema/schema.d.ts

@@ -0,0 +1,92 @@
+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];
+/**
+ * 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 * 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';
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +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"}

package/lib/esm/action/schema/schema.js

@@ -0,0 +1,21 @@
+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 * 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';

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

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

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

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

package/lib/esm/activity/index.js

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

package/lib/esm/activity/schema/base.d.ts

@@ -0,0 +1,54 @@
+export declare const ActivityIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export type ActivityId = typeof ActivityIdSchema.inferOut;
+export declare const ActivityIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+}, {}>;
+export type ActivityIdProperty = typeof ActivityIdPropertySchema.inferOut;
+export declare const SourceSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export declare const PerformedBySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    type: "system" | "guest" | "identity" | "automation" | "integration";
+    identifier: string;
+}, {}>;
+export type PerformedBy = typeof PerformedBySchema.inferOut;
+export declare const BasePayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    createdAt: (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;
+}, {}>;
+export declare const BaseInsertPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: import("arktype/internal/attributes.ts").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/internal/attributes.ts").Out<{
+        [x: string]: string | number | boolean;
+    } | null>) | undefined;
+}, {}>;
+export declare const BaseUpdatePayloadSchema: import("arktype/internal/methods/object.ts").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/internal/attributes.ts").Out<{
+        [x: string]: string | number | boolean;
+    } | null>) | undefined;
+}, {}>;
+//# sourceMappingURL=base.d.ts.map

package/lib/esm/activity/schema/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/activity/schema/base.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,gBAAgB,qEAAc,CAAC;AAC5C,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,QAAQ,CAAC;AAE1D,eAAO,MAAM,wBAAwB;;MAEnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,wBAAwB,CAAC,QAAQ,CAAC;AAE1E,eAAO,MAAM,YAAY,qEAAiB,CAAC;AAE3C,eAAO,MAAM,iBAAiB;;;MAS5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,QAAQ,CAAC;AAE5D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;MASO,CAAC;AAEtC,eAAO,MAAM,uBAAuB;;;;;;;;;;;MAGO,CAAC;AAE5C,eAAO,MAAM,uBAAuB;;;;;;;;;;MAEO,CAAC"}

package/lib/esm/activity/schema/base.js

@@ -0,0 +1,31 @@
+import { type } from 'arktype';
+import { OptionalDatePayloadSchema, RequiredDatePayloadSchema, } from '../../common/index.js';
+import { MetadataPayloadPropertySchema, UpsertMetadataPayloadPropertySchema, } from '../../common/schema/metadata.js';
+import { PerformerType } from './schema.js';
+import { generateActivityId } from './utils.js';
+export const ActivityIdSchema = type.string;
+export const ActivityIdPropertySchema = type({
+    id: ActivityIdSchema,
+});
+export const SourceSchema = type('string');
+export const PerformedBySchema = type({
+    type: type.enumerated(PerformerType.SYSTEM, PerformerType.GUEST, PerformerType.IDENTITY, PerformerType.AUTOMATION, PerformerType.INTEGRATION),
+    identifier: type('string'),
+});
+export const BasePayloadSchema = type({
+    id: ActivityIdSchema,
+    performedBy: PerformedBySchema,
+    source: SourceSchema,
+    isMutateable: type('boolean'),
+    createdAt: RequiredDatePayloadSchema,
+    updatedAt: RequiredDatePayloadSchema,
+    'deletedAt?': OptionalDatePayloadSchema,
+    'deactivatedAt?': OptionalDatePayloadSchema,
+}).and(MetadataPayloadPropertySchema);
+export const BaseInsertPayloadSchema = type({
+    id: ActivityIdSchema.default(() => generateActivityId()),
+    performedBy: PerformedBySchema.optional(),
+}).and(UpsertMetadataPayloadPropertySchema);
+export const BaseUpdatePayloadSchema = type({
+    performedBy: PerformedBySchema.optional(),
+}).and(UpsertMetadataPayloadPropertySchema);

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

@@ -0,0 +1,156 @@
+export declare const ActivityType: {
+    readonly UNKNOWN: "unknown";
+    readonly NOTE: "note";
+    readonly OPERATION: "operation";
+    readonly AUTHORIZATION: "authorization";
+    readonly AUTHENTICATION: "authentication";
+};
+export type AnyActivityType = (typeof ActivityType)[keyof typeof ActivityType];
+export declare const PerformerType: {
+    readonly SYSTEM: "system";
+    readonly GUEST: "guest";
+    readonly IDENTITY: "identity";
+    readonly AUTOMATION: "automation";
+    readonly INTEGRATION: "integration";
+};
+export type AnyPerformerType = (typeof PerformerType)[keyof typeof PerformerType];
+export declare const ActivityPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    createdAt: (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;
+    type: "authentication";
+    status: "success" | "fail";
+    identity: string;
+} | {
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    createdAt: (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;
+    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;
+    createdAt: (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;
+    type: "note";
+    message: string;
+} | {
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    createdAt: (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;
+    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;
+    createdAt: (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;
+    type: "unknown";
+    message: string;
+}, {}>;
+export type ActivityPayload = typeof ActivityPayloadSchema.inferOut;
+export declare const InsertActivityPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: import("arktype/internal/attributes.ts").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/internal/attributes.ts").Out<{
+        [x: string]: string | number | boolean;
+    } | null>) | undefined;
+    type: "note";
+    message: string;
+}, {}>;
+export type InsertActivityPayload = typeof InsertActivityPayloadSchema.inferOut;
+export declare const UpdateActivityPayloadSchema: import("arktype/internal/methods/object.ts").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/internal/attributes.ts").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 './schema.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/lib/esm/activity/schema/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/activity/schema/schema.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,YAAY;;;;;;CAMf,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE/E,eAAO,MAAM,aAAa;;;;;;CAMhB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAC1B,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAErD,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,aAAa,CAAC;AAC5B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AAEnC,cAAc,YAAY,CAAC"}

package/lib/esm/activity/schema/schema.js

@@ -0,0 +1,33 @@
+import { AuthenticationActivityPayloadSchema } from './types/authentication.js';
+import { AuthorizationActivityPayloadSchema } from './types/authorization.js';
+import { InsertNoteActivityPayloadSchema, NoteActivityPayloadSchema, UpdateNoteActivityPayloadSchema, } from './types/note.js';
+import { OperationActivityPayloadSchema } from './types/operation.js';
+import { UnknownActivityPayloadSchema } from './types/unknown.js';
+export const ActivityType = {
+    UNKNOWN: 'unknown',
+    NOTE: 'note',
+    OPERATION: 'operation',
+    AUTHORIZATION: 'authorization',
+    AUTHENTICATION: 'authentication',
+};
+export const PerformerType = {
+    SYSTEM: 'system',
+    GUEST: 'guest',
+    IDENTITY: 'identity',
+    AUTOMATION: 'automation',
+    INTEGRATION: 'integration',
+};
+export const ActivityPayloadSchema = NoteActivityPayloadSchema.or(AuthenticationActivityPayloadSchema)
+    .or(AuthorizationActivityPayloadSchema)
+    .or(OperationActivityPayloadSchema)
+    .or(UnknownActivityPayloadSchema);
+export const InsertActivityPayloadSchema = InsertNoteActivityPayloadSchema;
+export const UpdateActivityPayloadSchema = UpdateNoteActivityPayloadSchema;
+export { ActivityIdPropertySchema, ActivityIdSchema, PerformedBySchema, SourceSchema, } from './base.js';
+export * from './schema.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';

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

@@ -0,0 +1,29 @@
+export declare const AuthenticationStatus: {
+    readonly SUCESS: "success";
+    readonly FAIL: "fail";
+};
+export type AnyAuthenticationStatus = (typeof AuthenticationStatus)[keyof typeof AuthenticationStatus];
+export declare const AuthenticationStatusSchema: import("arktype/internal/methods/string.ts").StringType<"success" | "fail", {}>;
+export declare const AuthenticationActivityPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    createdAt: (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;
+    type: "authentication";
+    status: "success" | "fail";
+    identity: string;
+}, {}>;
+export type AuthenticationActivityPayload = typeof AuthenticationActivityPayloadSchema.inferOut;
+//# sourceMappingURL=authentication.d.ts.map

package/lib/esm/activity/schema/types/authentication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authentication.d.ts","sourceRoot":"","sources":["../../../../../src/activity/schema/types/authentication.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,oBAAoB;;;CAGvB,CAAC;AAEX,MAAM,MAAM,uBAAuB,GACjC,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC;AAEnE,eAAO,MAAM,0BAA0B,iFAGtC,CAAC;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;MAI9C,CAAC;AACH,MAAM,MAAM,6BAA6B,GACvC,OAAO,mCAAmC,CAAC,QAAQ,CAAC"}

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

@@ -0,0 +1,13 @@
+import { type } from 'arktype';
+import { UserIdSchema } from '../../../customer/schema/user.js';
+import { BasePayloadSchema } from '../base.js';
+export const AuthenticationStatus = {
+    SUCESS: 'success',
+    FAIL: 'fail',
+};
+export const AuthenticationStatusSchema = type.enumerated(AuthenticationStatus.SUCESS, AuthenticationStatus.FAIL);
+export const AuthenticationActivityPayloadSchema = BasePayloadSchema.and({
+    type: type("'authentication'"),
+    status: AuthenticationStatusSchema,
+    identity: UserIdSchema,
+});

package/lib/esm/activity/schema/types/authorization.d.ts

@@ -0,0 +1,29 @@
+export declare const AuthorizationStatus: {
+    readonly SUCESS: "success";
+    readonly FAIL: "fail";
+};
+export type AnyAuthorizationStatus = (typeof AuthorizationStatus)[keyof typeof AuthorizationStatus];
+export declare const AuthorizationActivityPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    performedBy: {
+        type: "system" | "guest" | "identity" | "automation" | "integration";
+        identifier: string;
+    };
+    source: string;
+    isMutateable: boolean;
+    createdAt: (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;
+    type: "authorization";
+    status: "success" | "fail";
+    message: string;
+    identity?: string | undefined;
+}, {}>;
+export type AuthorizationActivityPayload = typeof AuthorizationActivityPayloadSchema.inferOut;
+//# sourceMappingURL=authorization.d.ts.map

package/lib/esm/activity/schema/types/authorization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorization.d.ts","sourceRoot":"","sources":["../../../../../src/activity/schema/types/authorization.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,mBAAmB;;;CAGtB,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAChC,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAC;AAOjE,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;MAK7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GACtC,OAAO,kCAAkC,CAAC,QAAQ,CAAC"}

package/lib/esm/activity/schema/types/authorization.js

@@ -0,0 +1,14 @@
+import { type } from 'arktype';
+import { UserIdSchema } from '../../../customer/schema/user.js';
+import { BasePayloadSchema } from '../base.js';
+export const AuthorizationStatus = {
+    SUCESS: 'success',
+    FAIL: 'fail',
+};
+const StatusSchema = type.enumerated(AuthorizationStatus.SUCESS, AuthorizationStatus.FAIL);
+export const AuthorizationActivityPayloadSchema = BasePayloadSchema.and({
+    type: type("'authorization'"),
+    status: StatusSchema,
+    identity: UserIdSchema.optional(),
+    message: type('string'),
+});