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

package/dist/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/dist/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/dist/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/dist/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/dist/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/dist/esm/activity/schema/types/authentication.js

@@ -0,0 +1,13 @@
+import { type } from 'arktype';
+import { UserIdSchema } from '../../../customer/users/schema.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/dist/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/dist/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/dist/esm/activity/schema/types/authorization.js

@@ -0,0 +1,14 @@
+import { type } from 'arktype';
+import { UserIdSchema } from '../../../customer/users/schema.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'),
+});

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

@@ -0,0 +1,51 @@
+export declare const NoteActivityPayloadSchema: 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: "note";
+    message: string;
+}, {}>;
+export type NoteActivityPayload = typeof NoteActivityPayloadSchema.inferOut;
+export declare const InsertNoteActivityPayloadSchema: 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 InsertNoteActivityPayload = typeof InsertNoteActivityPayloadSchema.inferOut;
+export declare const UpdateNoteActivityPayloadSchema: 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 UpdateNoteActivityPayload = typeof UpdateNoteActivityPayloadSchema.inferOut;
+//# sourceMappingURL=note.d.ts.map

package/dist/esm/activity/schema/types/note.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"note.d.ts","sourceRoot":"","sources":["../../../../../src/activity/schema/types/note.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;MAGpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAE5E,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;MAG1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GACnC,OAAO,+BAA+B,CAAC,QAAQ,CAAC;AAElD,eAAO,MAAM,+BAA+B;;;;;;;;;;;;MAG1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GACnC,OAAO,+BAA+B,CAAC,QAAQ,CAAC"}

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

@@ -0,0 +1,14 @@
+import { type } from 'arktype';
+import { BaseInsertPayloadSchema, BasePayloadSchema, BaseUpdatePayloadSchema, } from '../base.js';
+export const NoteActivityPayloadSchema = BasePayloadSchema.and({
+    type: type("'note'"),
+    message: type('string'),
+});
+export const InsertNoteActivityPayloadSchema = BaseInsertPayloadSchema.and({
+    type: type("'note'"),
+    message: type('string'),
+});
+export const UpdateNoteActivityPayloadSchema = BaseUpdatePayloadSchema.and({
+    type: type("'note'"),
+    message: type('string').optional(),
+});

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

@@ -0,0 +1,31 @@
+export declare const OperationType: {
+    readonly CREATE: "create";
+    readonly UPDATE: "update";
+    readonly DELETE: "delete";
+    readonly AUTOMATION: "automation";
+};
+export type AnyOperationType = (typeof OperationType)[keyof typeof OperationType];
+export declare const OperationActivityPayloadSchema: 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: "operation";
+    operation: "delete" | "automation" | "create" | "update";
+    message: string;
+    target: string;
+}, {}>;
+export type OperationActivityPayload = typeof OperationActivityPayloadSchema.inferOut;
+//# sourceMappingURL=operation.d.ts.map

package/dist/esm/activity/schema/types/operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../../../src/activity/schema/types/operation.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;CAKhB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAC1B,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AASrD,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;MAKzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC"}

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

@@ -0,0 +1,15 @@
+import { type } from 'arktype';
+import { BasePayloadSchema } from '../base.js';
+export const OperationType = {
+    CREATE: 'create',
+    UPDATE: 'update',
+    DELETE: 'delete',
+    AUTOMATION: 'automation',
+};
+const OperationSchema = type.enumerated(OperationType.CREATE, OperationType.UPDATE, OperationType.DELETE, OperationType.AUTOMATION);
+export const OperationActivityPayloadSchema = BasePayloadSchema.and({
+    type: type("'operation'"),
+    operation: OperationSchema,
+    message: type('string'),
+    target: type('string'),
+});

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

@@ -0,0 +1,22 @@
+export declare const UnknownActivityPayloadSchema: 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: "unknown";
+    message: string;
+}, {}>;
+export type UnknownActivityPayload = typeof UnknownActivityPayloadSchema.inferOut;
+//# sourceMappingURL=unknown.d.ts.map

package/dist/esm/activity/schema/types/unknown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown.d.ts","sourceRoot":"","sources":["../../../../../src/activity/schema/types/unknown.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;MAGvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAChC,OAAO,4BAA4B,CAAC,QAAQ,CAAC"}

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

@@ -0,0 +1,6 @@
+import { type } from 'arktype';
+import { BasePayloadSchema } from '../base.js';
+export const UnknownActivityPayloadSchema = BasePayloadSchema.and({
+    type: type("'unknown'"),
+    message: type('string'),
+});

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

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

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

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

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

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

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

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

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

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

package/dist/esm/app/index.js

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

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

@@ -0,0 +1,58 @@
+export declare const AppStatus: {
+    readonly ENABLED: "enabled";
+    readonly DISABLED: "disabled";
+};
+export type AnyAppStatus = (typeof AppStatus)[keyof typeof AppStatus];
+export declare const AppIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export type AppId = typeof AppIdSchema.inferOut;
+export declare const AppIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+}, {}>;
+export type AppIdProperty = typeof AppIdPropertySchema.inferOut;
+export declare const AppPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    status: "enabled" | "disabled";
+    label: string;
+    createdAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+    description?: string | undefined;
+    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;
+    id: string;
+    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 type AppPayload = typeof AppPayloadSchema.inferOut;
+export declare const InsertAppPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: import("arktype/internal/attributes.ts").Default<string, string>;
+    status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "enabled">;
+    label: string;
+    description?: 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;
+    } | undefined>) | undefined;
+}, {}>;
+export type InsertAppPayload = typeof InsertAppPayloadSchema.inferOut;
+export declare const UpdateAppPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    status?: "enabled" | "disabled" | undefined;
+    label?: string | null | undefined;
+    description?: string | null | 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 type UpdateAppPayload = typeof UpdateAppPayloadSchema.inferOut;
+export declare const AppAssociationReferenceSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    status: "enabled" | "disabled";
+    label: string;
+    model: "App";
+}, {}>;
+export type AppAssociationReference = typeof AppAssociationReferenceSchema.inferOut;
+//# sourceMappingURL=app.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../../../src/app/schema/app.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,SAAS;;;CAGZ,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEtE,eAAO,MAAM,WAAW,qEAAc,CAAC;AACvC,MAAM,MAAM,KAAK,GAAG,OAAO,WAAW,CAAC,QAAQ,CAAC;AAEhD,eAAO,MAAM,mBAAmB;;MAE9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,mBAAmB,CAAC,QAAQ,CAAC;AAIhE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;MAUQ,CAAC;AACtC,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,QAAQ,CAAC;AAE1D,eAAO,MAAM,sBAAsB;;;;;;;;;;MAKE,CAAC;AACtC,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAEtE,eAAO,MAAM,sBAAsB;;;;;;;;;MAIE,CAAC;AACtC,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAEtE,eAAO,MAAM,6BAA6B;;;;;MAMzC,CAAC;AACF,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC"}

package/dist/esm/app/schema/app.js

@@ -0,0 +1,40 @@
+import { type } from 'arktype';
+import { OptionalDatePayloadSchema, RequiredDatePayloadSchema, } from '../../common/index.js';
+import { MetadataPayloadPropertySchema } from '../../common/schema/metadata.js';
+import { generateAppId } from './utils.js';
+export const AppStatus = {
+    ENABLED: 'enabled',
+    DISABLED: 'disabled',
+};
+export const AppIdSchema = type.string;
+export const AppIdPropertySchema = type({
+    id: AppIdSchema,
+});
+const StatusSchema = type.enumerated(AppStatus.ENABLED, AppStatus.DISABLED);
+export const AppPayloadSchema = type({
+    status: StatusSchema,
+    label: type('string'),
+    description: type('string | undefined').optional(),
+    createdAt: RequiredDatePayloadSchema,
+    updatedAt: RequiredDatePayloadSchema,
+    'deletedAt?': OptionalDatePayloadSchema,
+    'deactivatedAt?': OptionalDatePayloadSchema,
+})
+    .and(AppIdPropertySchema)
+    .and(MetadataPayloadPropertySchema);
+export const InsertAppPayloadSchema = type({
+    id: AppIdSchema.default(() => generateAppId()),
+    status: StatusSchema.default(AppStatus.ENABLED),
+    label: type('string'),
+    description: type('string').optional(),
+}).and(MetadataPayloadPropertySchema);
+export const UpdateAppPayloadSchema = type({
+    status: StatusSchema.optional(),
+    label: type('string').or(type.null).optional(),
+    description: type('string').or(type.null).optional(),
+}).and(MetadataPayloadPropertySchema);
+export const AppAssociationReferenceSchema = AppIdPropertySchema.and(type({
+    status: StatusSchema,
+    label: type('string'),
+    model: "'App'",
+}));

package/dist/esm/app/schema/authorization.d.ts

@@ -0,0 +1,37 @@
+import { type AnyGrantType } from '../../oauth/common/schema.js';
+export declare const AuthorizationPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    refreshTokenDuration: import("arktype/internal/attributes.ts").Default<number, number>;
+    accessTokenDuration: import("arktype/internal/attributes.ts").Default<number, number>;
+    accessTokenSignatureAlgorithm: import("arktype/internal/attributes.ts").Default<string, string>;
+    loginUri?: string | undefined;
+    callbackUrls?: ((In: Set<string> | string[] | undefined) => import("arktype/internal/attributes.ts").Out<string[] | undefined>) | undefined;
+    availableGrants?: ((In: Set<AnyGrantType> | ("client_credentials" | "authorization_code" | "implicit" | "refresh_token")[] | undefined) => import("arktype/internal/attributes.ts").Out<("client_credentials" | "authorization_code" | "implicit" | "refresh_token")[] | undefined>) | undefined;
+    availableAudiences?: ((In: Set<string> | string[] | undefined) => import("arktype/internal/attributes.ts").Out<string[] | undefined>) | undefined;
+    defaultAudience?: string | undefined;
+    updatedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
+    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 type AuthorizationPayload = typeof AuthorizationPayloadSchema.inferOut;
+export declare const UpsertAuthorizationPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    refreshTokenDuration: import("arktype/internal/attributes.ts").Default<number, number>;
+    accessTokenDuration: import("arktype/internal/attributes.ts").Default<number, number>;
+    accessTokenSignatureAlgorithm: import("arktype/internal/attributes.ts").Default<string, string>;
+    loginUri?: string | undefined;
+    callbackUrls?: ((In: Set<string> | string[] | undefined) => import("arktype/internal/attributes.ts").Out<string[] | undefined>) | undefined;
+    availableGrants?: ("client_credentials" | "authorization_code" | "implicit" | "refresh_token")[] | undefined;
+    availableAudiences?: string[] | undefined;
+    defaultAudience?: 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 type UpsertAuthorizationPayload = typeof UpsertAuthorizationPayloadSchema.inferOut;
+//# sourceMappingURL=authorization.d.ts.map

package/dist/esm/app/schema/authorization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorization.d.ts","sourceRoot":"","sources":["../../../../src/app/schema/authorization.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,YAAY,EAAa,MAAM,8BAA8B,CAAC;AAiC5E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;MASF,CAAC;AACtC,MAAM,MAAM,oBAAoB,GAAG,OAAO,0BAA0B,CAAC,QAAQ,CAAC;AAE9E,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;MAcF,CAAC;AAC5C,MAAM,MAAM,0BAA0B,GACpC,OAAO,gCAAgC,CAAC,QAAQ,CAAC"}