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

package/dist/esm/authentication/schema/factors.test.js

@@ -0,0 +1,121 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { AuthenticationFactorPayloadSchema, AuthenticationFactorsPayloadSchema, UpsertAuthenticationFactorsPayloadSchema, } from './factors.js';
+describe('Authentication - Factors', () => {
+    describe('Schema', () => {
+        test('should parse response payload successfully', async () => {
+            expect(AuthenticationFactorsPayloadSchema({
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                factors: [
+                    {
+                        id: '123',
+                    },
+                ],
+            })).not.toBeInstanceOf(type.errors);
+            // Undefined factors
+            expect(AuthenticationFactorsPayloadSchema({
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                factors: undefined,
+            })).not.toBeInstanceOf(type.errors);
+        });
+        test('should parse upsert payload successfully', async () => {
+            expect(UpsertAuthenticationFactorsPayloadSchema({
+                factors: [
+                    {
+                        id: '123',
+                    },
+                ],
+            })).not.toBeInstanceOf(type.errors);
+            // Null factors
+            expect(UpsertAuthenticationFactorsPayloadSchema({
+                factors: null,
+            })).not.toBeInstanceOf(type.errors);
+            // Undefined factors
+            expect(UpsertAuthenticationFactorsPayloadSchema({
+                factors: undefined,
+            })).not.toBeInstanceOf(type.errors);
+        });
+        test('should throw error for invalid factors', async () => {
+            // Factor object
+            expect(AuthenticationFactorsPayloadSchema({
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                factors: { id: '123' },
+            })).toBeInstanceOf(type.errors);
+            // Factor array of string
+            expect(AuthenticationFactorsPayloadSchema({
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                factors: ['123'],
+            })).toBeInstanceOf(type.errors);
+        });
+        test('should accept various next factors types', async () => {
+            // Undefined
+            expect(AuthenticationFactorPayloadSchema({
+                id: '123',
+                nextFactors: undefined,
+            })).not.toBeInstanceOf(type.errors);
+            // Array
+            expect(AuthenticationFactorPayloadSchema({
+                id: '123',
+                nextFactors: [
+                    {
+                        id: '456',
+                    },
+                ],
+            })).not.toBeInstanceOf(type.errors);
+            // Deeply nested array
+            expect(AuthenticationFactorPayloadSchema({
+                id: '123',
+                nextFactors: [
+                    {
+                        id: '456',
+                        nextFactors: [
+                            {
+                                id: '456',
+                                nextFactors: [
+                                    {
+                                        id: '456',
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            })).not.toBeInstanceOf(type.errors);
+        });
+        test('should throw error for invalid factor id', async () => {
+            // Number
+            expect(AuthenticationFactorsPayloadSchema({
+                id: 123,
+            })).toBeInstanceOf(type.errors);
+            // Null
+            expect(AuthenticationFactorsPayloadSchema({
+                id: null,
+            })).toBeInstanceOf(type.errors);
+            // Undefined
+            expect(AuthenticationFactorsPayloadSchema({
+                id: undefined,
+            })).toBeInstanceOf(type.errors);
+        });
+        test('should throw error for invalid next factors', async () => {
+            // String
+            expect(AuthenticationFactorsPayloadSchema({
+                id: '123',
+                nextFactors: '123',
+            })).toBeInstanceOf(type.errors);
+            // Object
+            expect(AuthenticationFactorsPayloadSchema({
+                id: '123',
+                nextFactors: { id: '123' },
+            })).toBeInstanceOf(type.errors);
+            // Array
+            expect(AuthenticationFactorsPayloadSchema({
+                id: '123',
+                nextFactors: ['123'],
+            })).toBeInstanceOf(type.errors);
+        });
+    });
+});

package/dist/esm/authentication/schema/provider.d.ts

@@ -0,0 +1,27 @@
+export declare const ProviderType: {
+    readonly MONDO: "mondo";
+};
+export type AnyProviderType = (typeof ProviderType)[keyof typeof ProviderType];
+export declare const ProviderIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export type ProviderId = typeof ProviderIdSchema.inferOut;
+export declare const ProviderIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+}, {}>;
+export type ProviderIdProperty = typeof ProviderIdPropertySchema.inferOut;
+export declare const ProviderTypeSchema: import("arktype/internal/methods/string.ts").StringType<"mondo", {}>;
+export declare const ProviderPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    type: "mondo";
+    user: string;
+    strategy: 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 type ProviderPayload = typeof ProviderPayloadSchema.inferOut;
+//# sourceMappingURL=provider.d.ts.map

package/dist/esm/authentication/schema/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../src/authentication/schema/provider.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,YAAY;;CAEf,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE/E,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,kBAAkB,sEAAsC,CAAC;AAEtE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;MAOG,CAAC;AACtC,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,QAAQ,CAAC"}

package/dist/esm/authentication/schema/provider.js

@@ -0,0 +1,21 @@
+import { type } from 'arktype';
+import { OptionalDatePayloadSchema, RequiredDatePayloadSchema, } from '../../common/schema/dates.js';
+import { MetadataPayloadPropertySchema } from '../../common/schema/metadata.js';
+import { UserIdSchema } from '../../customer/users/schema.js';
+import { StrategyIdSchema } from './strategy/base.js';
+export const ProviderType = {
+    MONDO: 'mondo',
+};
+export const ProviderIdSchema = type.string;
+export const ProviderIdPropertySchema = type({
+    id: ProviderIdSchema,
+});
+export const ProviderTypeSchema = type.enumerated(ProviderType.MONDO);
+export const ProviderPayloadSchema = ProviderIdPropertySchema.and({
+    type: ProviderTypeSchema,
+    user: UserIdSchema,
+    strategy: StrategyIdSchema,
+    updatedAt: RequiredDatePayloadSchema,
+    'deletedAt?': OptionalDatePayloadSchema,
+    'deactivatedAt?': OptionalDatePayloadSchema,
+}).and(MetadataPayloadPropertySchema);

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

@@ -0,0 +1,6 @@
+export * from './factors.js';
+export * from './provider.js';
+export * from './session.js';
+export * from './settings.js';
+export * from './strategy/schema.js';
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authentication/schema/schema.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC"}

package/dist/esm/authentication/schema/schema.js

@@ -0,0 +1,5 @@
+export * from './factors.js';
+export * from './provider.js';
+export * from './session.js';
+export * from './settings.js';
+export * from './strategy/schema.js';

package/dist/esm/authentication/schema/session.d.ts

@@ -0,0 +1,59 @@
+export declare const SessionStatus: {
+    readonly INITIATED: "initiated";
+    readonly AUTHENTICATED: "authenticated";
+    readonly PENDING: "pending";
+};
+export type AnySessionStatus = (typeof SessionStatus)[keyof typeof SessionStatus];
+export declare const SessionIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export type SessionId = typeof SessionIdSchema.inferOut;
+export declare const SessionIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+}, {}>;
+export type SessionIdProperty = typeof SessionIdPropertySchema.inferOut;
+export declare const SessionStatusSchema: import("arktype/internal/methods/string.ts").StringType<"initiated" | "authenticated" | "pending", {}>;
+export declare const AuthenticationFactorSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    type: "email" | "password" | "totp";
+    settings?: Record<string, unknown> | undefined;
+    state?: string | undefined;
+}, {}>;
+export type AuthenticationFactor = typeof AuthenticationFactorSchema.inferOut;
+export declare const AuthenticationFactorHistorySchema: import("arktype/internal/methods/object.ts").ObjectType<(In: string[] | Set<string> | undefined) => import("arktype/internal/attributes.ts").Out<string[] | Set<string> | undefined>, {}>;
+export type AuthenticationFactorHistory = typeof AuthenticationFactorHistorySchema.inferOut;
+export declare const SessionPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    status: "initiated" | "authenticated" | "pending";
+    expiresAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+    createdAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+    user?: string | undefined;
+    userAgent?: string | undefined;
+    sourceIp?: string | undefined;
+    factors?: {
+        id: string;
+        type: "email" | "password" | "totp";
+        settings?: Record<string, unknown> | undefined;
+        state?: string | undefined;
+    }[] | undefined;
+    factorHistory?: ((In: string[] | Set<string> | undefined) => import("arktype/internal/attributes.ts").Out<string[] | Set<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 SessionPayload = typeof SessionPayloadSchema.inferOut;
+export declare const SessionAssociationReferenceSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    status: "initiated" | "authenticated" | "pending";
+    expiresAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+    createdAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+    user?: string | undefined;
+    userAgent?: string | undefined;
+    sourceIp?: string | undefined;
+    model: "Session";
+}, {}>;
+export type SessionAssociationReference = typeof SessionAssociationReferenceSchema.inferOut;
+//# sourceMappingURL=session.d.ts.map

package/dist/esm/authentication/schema/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../src/authentication/schema/session.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,aAAa;;;;CAIhB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAC1B,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAErD,eAAO,MAAM,eAAe,qEAAc,CAAC;AAC3C,MAAM,MAAM,SAAS,GAAG,OAAO,eAAe,CAAC,QAAQ,CAAC;AAExD,eAAO,MAAM,uBAAuB;;MAElC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE,eAAO,MAAM,mBAAmB,wGAI/B,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;MAKrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,0BAA0B,CAAC,QAAQ,CAAC;AAM9E,eAAO,MAAM,iCAAiC,2LAK3C,CAAC;AACJ,MAAM,MAAM,2BAA2B,GACrC,OAAO,iCAAiC,CAAC,QAAQ,CAAC;AAEpD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;MAYI,CAAC;AACtC,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,QAAQ,CAAC;AAElE,eAAO,MAAM,iCAAiC;;;;;;;;;MAU5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GACrC,OAAO,iCAAiC,CAAC,QAAQ,CAAC"}

package/dist/esm/authentication/schema/session.js

@@ -0,0 +1,43 @@
+import { type } from 'arktype';
+import { OptionalDatePayloadSchema, RequiredDatePayloadSchema, } from '../../common/schema/dates.js';
+import { MetadataPayloadPropertySchema } from '../../common/schema/metadata.js';
+import { UserIdSchema } from '../../customer/users/schema.js';
+import { StrategyIdSchema, StrategyTypeSchema } from './strategy/base.js';
+export const SessionStatus = {
+    INITIATED: 'initiated', // Session was created, but no activity has been taken
+    AUTHENTICATED: 'authenticated', // Session is authenticated
+    PENDING: 'pending', // Session is in the process of authenticating
+};
+export const SessionIdSchema = type.string;
+export const SessionIdPropertySchema = type({
+    id: SessionIdSchema,
+});
+export const SessionStatusSchema = type.enumerated(SessionStatus.INITIATED, SessionStatus.AUTHENTICATED, SessionStatus.PENDING);
+export const AuthenticationFactorSchema = type({
+    id: StrategyIdSchema,
+    type: StrategyTypeSchema,
+    settings: type('Record<string, unknown> | undefined').optional(),
+    state: type('string | undefined').optional(),
+});
+const AuthenticationFactorHistoryArraySchema = StrategyIdSchema.array();
+const AuthenticationFactorHistorySetSchema = type.instanceOf((Set));
+export const AuthenticationFactorHistorySchema = type('undefined')
+    .or(AuthenticationFactorHistoryArraySchema)
+    .or(AuthenticationFactorHistorySetSchema)
+    .pipe((s) => (s instanceof Set ? Array.from(s) : s)?.length ? s : undefined);
+export const SessionPayloadSchema = SessionIdPropertySchema.and({
+    status: SessionStatusSchema,
+    user: UserIdSchema.or('undefined').optional(),
+    userAgent: type('string | undefined').optional(),
+    sourceIp: type('string.ip.v4 | string.ip.v6	| undefined').optional(),
+    factors: AuthenticationFactorSchema.array().or('undefined').optional(),
+    factorHistory: AuthenticationFactorHistorySchema.optional(),
+    expiresAt: RequiredDatePayloadSchema,
+    createdAt: RequiredDatePayloadSchema,
+    updatedAt: RequiredDatePayloadSchema,
+    'deletedAt?': OptionalDatePayloadSchema,
+    'deactivatedAt?': OptionalDatePayloadSchema,
+}).and(MetadataPayloadPropertySchema);
+export const SessionAssociationReferenceSchema = SessionPayloadSchema.pick('id', 'status', 'user', 'userAgent', 'sourceIp', 'createdAt', 'expiresAt').and({
+    model: "'Session'",
+});

package/dist/esm/authentication/schema/settings.d.ts

@@ -0,0 +1,46 @@
+export declare const SettingsPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    factors?: ((In: {
+        id: string;
+        nextFactors?: {
+            id: string;
+            nextFactors?: /*elided*/ any[] | null | undefined;
+        }[] | null | undefined;
+    }[] | null | undefined) => import("arktype/internal/attributes.ts").Out<{
+        id: string;
+        nextFactors?: {
+            id: string;
+            nextFactors?: /*elided*/ any[] | null | undefined;
+        }[] | null | undefined;
+    }[] | undefined>) | 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 SettingsPayload = typeof SettingsPayloadSchema.inferOut;
+export declare const UpsertSettingsPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    factors?: ((In: {
+        id: string;
+        nextFactors?: {
+            id: string;
+            nextFactors?: /*elided*/ any[] | null | undefined;
+        }[] | null | undefined;
+    }[] | null | undefined) => import("arktype/internal/attributes.ts").Out<{
+        id: string;
+        nextFactors?: {
+            id: string;
+            nextFactors?: /*elided*/ any[] | null | undefined;
+        }[] | null | undefined;
+    }[] | 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;
+    } | null>) | undefined;
+}, {}>;
+export type UpsertSettingsPayload = typeof UpsertSettingsPayloadSchema.inferOut;
+//# sourceMappingURL=settings.d.ts.map

package/dist/esm/authentication/schema/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../../../src/authentication/schema/settings.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;MAMG,CAAC;AACtC,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,QAAQ,CAAC;AAEpE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;MAEG,CAAC;AAC5C,MAAM,MAAM,qBAAqB,GAAG,OAAO,2BAA2B,CAAC,QAAQ,CAAC"}

package/dist/esm/authentication/schema/settings.js

@@ -0,0 +1,13 @@
+import { type } from 'arktype';
+import { OptionalDatePayloadSchema } from '../../common/schema/dates.js';
+import { MetadataPayloadPropertySchema, UpsertMetadataPayloadPropertySchema, } from '../../common/schema/metadata.js';
+import { AuthenticationFactorsSchema } from './factors.js';
+export const SettingsPayloadSchema = type({
+    factors: AuthenticationFactorsSchema.optional(),
+    'updatedAt?': OptionalDatePayloadSchema,
+    'deletedAt?': OptionalDatePayloadSchema,
+    'deactivatedAt?': OptionalDatePayloadSchema,
+}).and(MetadataPayloadPropertySchema);
+export const UpsertSettingsPayloadSchema = type({
+    factors: AuthenticationFactorsSchema.optional(),
+}).and(UpsertMetadataPayloadPropertySchema);

package/dist/esm/authentication/schema/strategy/base.d.ts

@@ -0,0 +1,54 @@
+export declare const StrategyType: {
+    readonly EMAIL: "email";
+    readonly PASSWORD: "password";
+    readonly TOTP: "totp";
+};
+export type AnyStrategyType = (typeof StrategyType)[keyof typeof StrategyType];
+export declare const StrategyStatus: {
+    readonly ENABLED: "enabled";
+    readonly DISABLED: "disabled";
+};
+export type AnyStrategyStatus = (typeof StrategyStatus)[keyof typeof StrategyStatus];
+export declare const StrategyIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export type StrategyId = typeof StrategyIdSchema.inferOut;
+export declare const StrategyIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+}, {}>;
+export type StrategyIdProperty = typeof StrategyIdPropertySchema.inferOut;
+export declare const StrategyStatusSchema: import("arktype/internal/methods/string.ts").StringType<"enabled" | "disabled", {}>;
+export declare const StrategyTypeSchema: import("arktype/internal/methods/string.ts").StringType<"email" | "password" | "totp", {}>;
+export declare const StrategyLabelSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export declare const BaseStrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    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>;
+    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 BaseInsertStrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    label: string;
+    status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "enabled">;
+    id?: 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 declare const BaseUpdateStrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    label?: string | undefined;
+    status?: "enabled" | "disabled" | 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;
+}, {}>;
+//# sourceMappingURL=base.d.ts.map

package/dist/esm/authentication/schema/strategy/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../../src/authentication/schema/strategy/base.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,YAAY;;;;CAIf,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE/E,eAAO,MAAM,cAAc;;;CAGjB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAC3B,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAEvD,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,oBAAoB,qFAGhC,CAAC;AACF,eAAO,MAAM,kBAAkB,4FAI9B,CAAC;AACF,eAAO,MAAM,mBAAmB,qEAAiB,CAAC;AAElD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;MAOD,CAAC;AAEtC,eAAO,MAAM,+BAA+B;;;;;;;;;MAIP,CAAC;AAEtC,eAAO,MAAM,+BAA+B;;;;;;;;MAGP,CAAC"}

package/dist/esm/authentication/schema/strategy/base.js

@@ -0,0 +1,36 @@
+import { type } from 'arktype';
+import { OptionalDatePayloadSchema, RequiredDatePayloadSchema, } from '../../../common/index.js';
+import { MetadataPayloadPropertySchema } from '../../../common/schema/metadata.js';
+export const StrategyType = {
+    EMAIL: 'email',
+    PASSWORD: 'password',
+    TOTP: 'totp',
+};
+export const StrategyStatus = {
+    ENABLED: 'enabled',
+    DISABLED: 'disabled',
+};
+export const StrategyIdSchema = type.string;
+export const StrategyIdPropertySchema = type({
+    id: StrategyIdSchema,
+});
+export const StrategyStatusSchema = type.enumerated(StrategyStatus.ENABLED, StrategyStatus.DISABLED);
+export const StrategyTypeSchema = type.enumerated(StrategyType.EMAIL, StrategyType.PASSWORD, StrategyType.TOTP);
+export const StrategyLabelSchema = type('string');
+export const BaseStrategyPayloadSchema = StrategyIdPropertySchema.and({
+    status: StrategyStatusSchema,
+    label: StrategyLabelSchema,
+    createdAt: RequiredDatePayloadSchema,
+    updatedAt: RequiredDatePayloadSchema,
+    'deletedAt?': OptionalDatePayloadSchema,
+    'deactivatedAt?': OptionalDatePayloadSchema,
+}).and(MetadataPayloadPropertySchema);
+export const BaseInsertStrategyPayloadSchema = type({
+    id: StrategyIdSchema.optional(),
+    label: StrategyLabelSchema,
+    status: StrategyStatusSchema.default(StrategyStatus.ENABLED),
+}).and(MetadataPayloadPropertySchema);
+export const BaseUpdateStrategyPayloadSchema = type({
+    label: StrategyLabelSchema.optional(),
+    status: StrategyStatusSchema.optional(),
+}).and(MetadataPayloadPropertySchema);

package/dist/esm/authentication/schema/strategy/schema.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Union(s)
+ */
+export declare const InsertStrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    label: string;
+    status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "enabled">;
+    id?: 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;
+    type: "email";
+} | {
+    label: string;
+    status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "enabled">;
+    id?: 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;
+    type: "password";
+    settings: {
+        passwordPolicy: {
+            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>;
+        };
+    };
+} | {
+    label: string;
+    status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "enabled">;
+    id?: 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;
+    type: "totp";
+    settings: {
+        digits: import("arktype/internal/attributes.ts").Default<6 | 7 | 8, 6>;
+        period: import("arktype/internal/attributes.ts").Default<15 | 30 | 60, 30>;
+        algorithm: import("arktype/internal/attributes.ts").Default<string, string>;
+    };
+}, {}>;
+export type InsertStrategyPayload = typeof InsertStrategyPayloadSchema.inferOut;
+export declare const UpdateStrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    label?: string | undefined;
+    status?: "enabled" | "disabled" | 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: "email";
+} | {
+    label?: string | undefined;
+    status?: "enabled" | "disabled" | 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: "password";
+    settings: {
+        passwordPolicy: {
+            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>;
+        };
+    };
+} | {
+    label?: string | undefined;
+    status?: "enabled" | "disabled" | 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: "totp";
+    settings: {
+        digits: import("arktype/internal/attributes.ts").Default<6 | 7 | 8, 6>;
+        period: import("arktype/internal/attributes.ts").Default<15 | 30 | 60, 30>;
+        algorithm: import("arktype/internal/attributes.ts").Default<string, string>;
+    };
+}, {}>;
+export type UpdateStrategyPayload = typeof UpdateStrategyPayloadSchema.inferOut;
+export declare const StrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    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>;
+    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: "email";
+} | {
+    id: string;
+    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>;
+    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: "password";
+    settings: {
+        passwordPolicy: {
+            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;
+    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>;
+    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: "totp";
+    settings: {
+        digits: import("arktype/internal/attributes.ts").Default<6 | 7 | 8, 6>;
+        period: import("arktype/internal/attributes.ts").Default<15 | 30 | 60, 30>;
+        algorithm: import("arktype/internal/attributes.ts").Default<string, string>;
+    };
+}, {}>;
+export type StrategyPayload = typeof StrategyPayloadSchema.inferOut;
+export { BaseInsertStrategyPayloadSchema, BaseStrategyPayloadSchema, BaseUpdateStrategyPayloadSchema, StrategyIdPropertySchema, StrategyIdSchema, StrategyLabelSchema, StrategyStatus, StrategyStatusSchema, StrategyType, type AnyStrategyStatus, type AnyStrategyType, type StrategyId, type StrategyIdProperty, } from './base.js';
+export * from './types/email.js';
+export * from './types/password.js';
+export * from './types/totp.js';
+//# sourceMappingURL=schema.d.ts.map

package/dist/esm/authentication/schema/strategy/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../src/authentication/schema/strategy/schema.ts"],"names":[],"mappings":"AAgBA;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAGrC,CAAC;AACJ,MAAM,MAAM,qBAAqB,GAAG,OAAO,2BAA2B,CAAC,QAAQ,CAAC;AAEhF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAGrC,CAAC;AACJ,MAAM,MAAM,qBAAqB,GAAG,OAAO,2BAA2B,CAAC,QAAQ,CAAC;AAEhF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEjC,CAAC;AACF,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,QAAQ,CAAC;AAEpE,OAAO,EACL,+BAA+B,EAC/B,yBAAyB,EACzB,+BAA+B,EAC/B,wBAAwB,EACxB,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACpB,YAAY,EACZ,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,UAAU,EACf,KAAK,kBAAkB,GACxB,MAAM,WAAW,CAAC;AACnB,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC"}

package/dist/esm/authentication/schema/strategy/schema.js

@@ -0,0 +1,13 @@
+import { EmailStrategyPayloadSchema, InsertEmailStrategyPayloadSchema, UpdateEmailStrategyPayloadSchema, } from './types/email.js';
+import { InsertPasswordStrategyPayloadSchema, PasswordStrategyPayloadSchema, UpdatePasswordStrategyPayloadSchema, } from './types/password.js';
+import { InsertTOTPStrategyPayloadSchema, TOTPStrategyPayloadSchema, UpdateTOTPStrategyPayloadSchema, } from './types/totp.js';
+/**
+ * Union(s)
+ */
+export const InsertStrategyPayloadSchema = InsertPasswordStrategyPayloadSchema.or(InsertEmailStrategyPayloadSchema).or(InsertTOTPStrategyPayloadSchema);
+export const UpdateStrategyPayloadSchema = UpdatePasswordStrategyPayloadSchema.or(UpdateEmailStrategyPayloadSchema).or(UpdateTOTPStrategyPayloadSchema);
+export const StrategyPayloadSchema = PasswordStrategyPayloadSchema.or(EmailStrategyPayloadSchema.or(TOTPStrategyPayloadSchema));
+export { BaseInsertStrategyPayloadSchema, BaseStrategyPayloadSchema, BaseUpdateStrategyPayloadSchema, StrategyIdPropertySchema, StrategyIdSchema, StrategyLabelSchema, StrategyStatus, StrategyStatusSchema, StrategyType, } from './base.js';
+export * from './types/email.js';
+export * from './types/password.js';
+export * from './types/totp.js';