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

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

@@ -0,0 +1,43 @@
+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/lib/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":"AAQA,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/lib/esm/authentication/schema/strategy/base.js

@@ -0,0 +1,28 @@
+import { type } from 'arktype';
+import { OptionalDatePayloadSchema, RequiredDatePayloadSchema, } from '../../../common/index.js';
+import { MetadataPayloadPropertySchema } from '../../../common/schema/metadata.js';
+import { StrategyStatus, StrategyType } from './schema.js';
+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/lib/esm/authentication/schema/strategy/schema.d.ts

@@ -0,0 +1,169 @@
+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];
+/**
+ * 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, StrategyStatusSchema, 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/lib/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,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;;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,oBAAoB,EACpB,KAAK,UAAU,EACf,KAAK,kBAAkB,GACxB,MAAM,WAAW,CAAC;AACnB,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC"}

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

@@ -0,0 +1,22 @@
+import { EmailStrategyPayloadSchema, InsertEmailStrategyPayloadSchema, UpdateEmailStrategyPayloadSchema, } from './types/email.js';
+import { InsertPasswordStrategyPayloadSchema, PasswordStrategyPayloadSchema, UpdatePasswordStrategyPayloadSchema, } from './types/password.js';
+import { InsertTOTPStrategyPayloadSchema, TOTPStrategyPayloadSchema, UpdateTOTPStrategyPayloadSchema, } from './types/totp.js';
+export const StrategyType = {
+    EMAIL: 'email',
+    PASSWORD: 'password',
+    TOTP: 'totp',
+};
+export const StrategyStatus = {
+    ENABLED: 'enabled',
+    DISABLED: 'disabled',
+};
+/**
+ * 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, StrategyStatusSchema, } from './base.js';
+export * from './types/email.js';
+export * from './types/password.js';
+export * from './types/totp.js';

package/lib/esm/authentication/schema/strategy/types/email.d.ts

@@ -0,0 +1,44 @@
+export declare const EmailStrategyPayloadSchema: 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";
+}, {}>;
+export declare const InsertEmailStrategyPayloadSchema: 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";
+}, {}>;
+export declare const UpdateEmailStrategyPayloadSchema: 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";
+}, {}>;
+export declare const VerifyEmailSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    code: string;
+    email?: string | undefined;
+}, {}>;
+export declare const SendEmailVerificationCodeSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    email?: string | undefined;
+}, {}>;
+//# sourceMappingURL=email.d.ts.map

package/lib/esm/authentication/schema/strategy/types/email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.d.ts","sourceRoot":"","sources":["../../../../../../src/authentication/schema/strategy/types/email.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;MACI,CAAC;AAE5C,eAAO,MAAM,gCAAgC;;;;;;;;;;MACI,CAAC;AAElD,eAAO,MAAM,gCAAgC;;;;;;;;;MACI,CAAC;AAElD,eAAO,MAAM,iBAAiB;;;MAK5B,CAAC;AAEH,eAAO,MAAM,+BAA+B;;MAE1C,CAAC"}

package/lib/esm/authentication/schema/strategy/types/email.js

@@ -0,0 +1,17 @@
+import { type } from 'arktype';
+import { BaseInsertStrategyPayloadSchema, BaseStrategyPayloadSchema, BaseUpdateStrategyPayloadSchema, } from '../base.js';
+const TypeSchema = type({
+    type: "'email'",
+});
+export const EmailStrategyPayloadSchema = BaseStrategyPayloadSchema.and(TypeSchema);
+export const InsertEmailStrategyPayloadSchema = BaseInsertStrategyPayloadSchema.and(TypeSchema);
+export const UpdateEmailStrategyPayloadSchema = BaseUpdateStrategyPayloadSchema.and(TypeSchema);
+export const VerifyEmailSchema = type({
+    email: type('string.email').optional(),
+    code: type('string').configure({
+        message: 'A verification code is required',
+    }),
+});
+export const SendEmailVerificationCodeSchema = type({
+    email: type('string.email').optional(),
+});

package/lib/esm/authentication/schema/strategy/types/password.d.ts

@@ -0,0 +1,99 @@
+export declare const PasswordPolicySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    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>;
+}, {}>;
+export declare const PasswordStrategySettingsSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    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>;
+        };
+    };
+}, {}>;
+export declare const PasswordStrategyPayloadSchema: 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: "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>;
+        };
+    };
+}, {}>;
+export type PasswordStrategyPayload = typeof PasswordStrategyPayloadSchema.inferOut;
+export declare const InsertPasswordStrategyPayloadSchema: 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: "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>;
+        };
+    };
+}, {}>;
+export type InsertPasswordStrategyPayload = typeof InsertPasswordStrategyPayloadSchema.inferOut;
+export declare const UpdatePasswordStrategyPayloadSchema: 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: "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>;
+        };
+    };
+}, {}>;
+export type UpdatePasswordStrategyPayload = typeof UpdatePasswordStrategyPayloadSchema.inferOut;
+export declare const ForgotPasswordSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    identifier?: string | undefined;
+    identifierType?: "email" | "phoneNumber" | undefined;
+}, {}>;
+export declare const VerifyPasswordSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    password: string;
+    identifier?: string | undefined;
+    identifierType?: "email" | "phoneNumber" | undefined;
+}, {}>;
+//# sourceMappingURL=password.d.ts.map

package/lib/esm/authentication/schema/strategy/types/password.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"password.d.ts","sourceRoot":"","sources":["../../../../../../src/authentication/schema/strategy/types/password.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,oBAAoB;;;;;;;MAO/B,CAAC;AAMH,eAAO,MAAM,8BAA8B;;;;;;;;;;;MAEzC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;MAEL,CAAC;AACtC,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC;AAEhD,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;MAG7C,CAAC;AACJ,MAAM,MAAM,6BAA6B,GACvC,OAAO,mCAAmC,CAAC,QAAQ,CAAC;AAEtD,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;MAG7C,CAAC;AACJ,MAAM,MAAM,6BAA6B,GACvC,OAAO,mCAAmC,CAAC,QAAQ,CAAC;AAEtD,eAAO,MAAM,oBAAoB;;;MAG/B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;MAI/B,CAAC"}

package/lib/esm/authentication/schema/strategy/types/password.js

@@ -0,0 +1,32 @@
+import { type } from 'arktype';
+import { IdentityIdentifierSchema } from '../../../../identity/schema/schema.js';
+import { BaseInsertStrategyPayloadSchema, BaseStrategyPayloadSchema, BaseUpdateStrategyPayloadSchema, } from '../base.js';
+const TypeSchema = type({
+    type: "'password'",
+});
+export const PasswordPolicySchema = type({
+    minimumLength: type.number.default(8),
+    maximumLength: type.number.default(36),
+    minimumCapital: type.number.default(1),
+    minimumLower: type.number.default(1),
+    minimumNumber: type.number.default(1),
+    minimumSpecial: type.number.default(1),
+});
+const SettingsSchema = type({
+    passwordPolicy: PasswordPolicySchema,
+});
+export const PasswordStrategySettingsSchema = type({
+    settings: SettingsSchema,
+});
+export const PasswordStrategyPayloadSchema = BaseStrategyPayloadSchema.and(TypeSchema).and(PasswordStrategySettingsSchema);
+export const InsertPasswordStrategyPayloadSchema = BaseInsertStrategyPayloadSchema.and(TypeSchema).and(PasswordStrategySettingsSchema);
+export const UpdatePasswordStrategyPayloadSchema = BaseUpdateStrategyPayloadSchema.and(TypeSchema).and(PasswordStrategySettingsSchema);
+export const ForgotPasswordSchema = type({
+    identifier: type('string').optional(),
+    identifierType: IdentityIdentifierSchema.optional(),
+});
+export const VerifyPasswordSchema = type({
+    password: type('string'),
+    identifier: type('string').optional(),
+    identifierType: IdentityIdentifierSchema.optional(),
+});

package/lib/esm/authentication/schema/strategy/types/totp.d.ts

@@ -0,0 +1,91 @@
+export declare const DEFAULT_DIGITS = 6;
+export declare const DEFAULT_PERIOD = 30;
+export declare const TOTPAlgorithm: {
+    DEFAULT: string;
+    SHA1: string;
+    SHA224: string;
+    SHA256: string;
+    SHA384: string;
+    SHA512: string;
+    'SHA3-224': string;
+    'SHA3-256': string;
+    'SHA3-384': string;
+    'SHA3-512': string;
+};
+export type AnyTOTPAlgorithm = (typeof TOTPAlgorithm)[keyof typeof TOTPAlgorithm];
+export declare const TOTPStrategySettingsSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    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 TOTPStrategySettings = typeof TOTPStrategySettingsSchema.inferOut;
+export declare const TOTPStrategySettingsPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    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 TOTPStrategySettingsProperty = typeof TOTPStrategySettingsPropertySchema.inferOut;
+export declare const TOTPStrategyPayloadSchema: 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: "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 TOTPStrategyPayload = typeof TOTPStrategyPayloadSchema.inferOut;
+export declare const InsertTOTPStrategyPayloadSchema: 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: "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 InsertTOTPStrategyPayload = typeof InsertTOTPStrategyPayloadSchema.inferOut;
+export declare const UpdateTOTPStrategyPayloadSchema: 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: "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 UpdateTOTPStrategyPayload = typeof UpdateTOTPStrategyPayloadSchema.inferOut;
+export declare const RegisterTOTPSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    uri: string;
+    token: string;
+}, {}>;
+export declare const VerifyTOTPSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    token: string;
+}, {}>;
+//# sourceMappingURL=totp.d.ts.map

package/lib/esm/authentication/schema/strategy/types/totp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"totp.d.ts","sourceRoot":"","sources":["../../../../../../src/authentication/schema/strategy/types/totp.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,eAAO,MAAM,cAAc,KAAK,CAAC;AAMjC,eAAO,MAAM,aAAa;;;;;;;;;;;CAWzB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAC1B,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAErD,eAAO,MAAM,0BAA0B;;;;MAgBrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,0BAA0B,CAAC,QAAQ,CAAC;AAE9E,eAAO,MAAM,kCAAkC;;;;;;MAE7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GACtC,OAAO,kCAAkC,CAAC,QAAQ,CAAC;AAErD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;MAEG,CAAC;AAC1C,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAE5E,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;MAGzC,CAAC;AACJ,MAAM,MAAM,yBAAyB,GACnC,OAAO,+BAA+B,CAAC,QAAQ,CAAC;AAElD,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;MAGzC,CAAC;AACJ,MAAM,MAAM,yBAAyB,GACnC,OAAO,+BAA+B,CAAC,QAAQ,CAAC;AAElD,eAAO,MAAM,kBAAkB;;;MAO7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;MAI3B,CAAC"}

package/lib/esm/authentication/schema/strategy/types/totp.js

@@ -0,0 +1,45 @@
+import { type } from 'arktype';
+import { BaseInsertStrategyPayloadSchema, BaseStrategyPayloadSchema, BaseUpdateStrategyPayloadSchema, } from '../base.js';
+export const DEFAULT_DIGITS = 6;
+export const DEFAULT_PERIOD = 30;
+const TypeSchema = type({
+    type: "'totp'",
+});
+export const TOTPAlgorithm = {
+    DEFAULT: 'SHA256',
+    SHA1: 'SHA1',
+    SHA224: 'SHA224',
+    SHA256: 'SHA256',
+    SHA384: 'SHA384',
+    SHA512: 'SHA512',
+    'SHA3-224': 'SHA3-224',
+    'SHA3-256': 'SHA3-256',
+    'SHA3-384': 'SHA3-384',
+    'SHA3-512': 'SHA3-512',
+};
+export const TOTPStrategySettingsSchema = type({
+    digits: type.enumerated(6, 7, 8).default(DEFAULT_DIGITS),
+    period: type.enumerated(15, 30, 60).default(DEFAULT_PERIOD),
+    algorithm: type
+        .enumerated(TOTPAlgorithm.SHA1, TOTPAlgorithm.SHA224, TOTPAlgorithm.SHA256, TOTPAlgorithm.SHA384, TOTPAlgorithm.SHA512, TOTPAlgorithm['SHA3-224'], TOTPAlgorithm['SHA3-256'], TOTPAlgorithm['SHA3-384'], TOTPAlgorithm['SHA3-512'])
+        .default(TOTPAlgorithm.DEFAULT),
+});
+export const TOTPStrategySettingsPropertySchema = type({
+    settings: TOTPStrategySettingsSchema,
+});
+export const TOTPStrategyPayloadSchema = BaseStrategyPayloadSchema.and(TypeSchema).and(TOTPStrategySettingsPropertySchema);
+export const InsertTOTPStrategyPayloadSchema = BaseInsertStrategyPayloadSchema.and(TypeSchema).and(TOTPStrategySettingsPropertySchema);
+export const UpdateTOTPStrategyPayloadSchema = BaseUpdateStrategyPayloadSchema.and(TypeSchema).and(TOTPStrategySettingsPropertySchema);
+export const RegisterTOTPSchema = type({
+    uri: type('string.url').configure({
+        message: 'An authenticator uri is required',
+    }),
+    token: type('string').configure({
+        message: 'An authenticator token is required',
+    }),
+});
+export const VerifyTOTPSchema = type({
+    token: type('string').configure({
+        message: 'An authenticator token is required',
+    }),
+});

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

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

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

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

package/lib/esm/authorization/index.js

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