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

package/dist/cjs/authentication/strategies/schema/types/password.d.ts

@@ -0,0 +1,131 @@
+export declare const PasswordPolicyDefaults: {
+    minimumLength: number;
+    maximumLength: number;
+    minimumCapital: number;
+    minimumLower: number;
+    minimumNumber: number;
+    minimumSpecial: number;
+};
+export declare const PasswordPolicySchema: import("arktype/out/methods/object.js").ObjectType<{
+    minimumLength: import("arktype/out/attributes.js").Default<number, number>;
+    maximumLength: import("arktype/out/attributes.js").Default<number, number>;
+    minimumCapital: import("arktype/out/attributes.js").Default<number, number>;
+    minimumLower: import("arktype/out/attributes.js").Default<number, number>;
+    minimumNumber: import("arktype/out/attributes.js").Default<number, number>;
+    minimumSpecial: import("arktype/out/attributes.js").Default<number, number>;
+}, {}>;
+export declare const PasswordStrategySettingsPropertySchema: import("arktype/out/methods/object.js").ObjectType<{
+    settings: {
+        passwordPolicy: {
+            minimumLength: import("arktype/out/attributes.js").Default<number, number>;
+            maximumLength: import("arktype/out/attributes.js").Default<number, number>;
+            minimumCapital: import("arktype/out/attributes.js").Default<number, number>;
+            minimumLower: import("arktype/out/attributes.js").Default<number, number>;
+            minimumNumber: import("arktype/out/attributes.js").Default<number, number>;
+            minimumSpecial: import("arktype/out/attributes.js").Default<number, number>;
+        };
+    };
+}, {}>;
+export declare const PasswordStrategySchema: import("arktype/out/methods/object.js").ObjectType<{
+    id: string;
+    status: import("arktype/out/attributes.js").Default<"enabled" | "disabled", "enabled">;
+    label: string;
+    createdAt: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>);
+    updatedAt: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>);
+    deletedAt?: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>) | undefined;
+    deactivatedAt?: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>) | undefined;
+    metadata: (In: import("arktype/out/attributes.js").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
+    type: "password";
+    settings: {
+        passwordPolicy: {
+            minimumLength: import("arktype/out/attributes.js").Default<number, number>;
+            maximumLength: import("arktype/out/attributes.js").Default<number, number>;
+            minimumCapital: import("arktype/out/attributes.js").Default<number, number>;
+            minimumLower: import("arktype/out/attributes.js").Default<number, number>;
+            minimumNumber: import("arktype/out/attributes.js").Default<number, number>;
+            minimumSpecial: import("arktype/out/attributes.js").Default<number, number>;
+        };
+    };
+}, {}>;
+export type PasswordStrategyProperties = typeof PasswordStrategySchema.inferIn;
+export type PasswordStrategy = typeof PasswordStrategySchema.inferOut;
+export declare const PasswordStrategyPayloadSchema: import("arktype/out/methods/object.js").ObjectType<{
+    status: "enabled" | "disabled";
+    label: string;
+    createdAt: (In: string | Date) => import("arktype").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype").Out<string>;
+    deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    type: "password";
+    settings: {
+        passwordPolicy: {
+            minimumLength: import("arktype/out/attributes.js").Default<number, number>;
+            maximumLength: import("arktype/out/attributes.js").Default<number, number>;
+            minimumCapital: import("arktype/out/attributes.js").Default<number, number>;
+            minimumLower: import("arktype/out/attributes.js").Default<number, number>;
+            minimumNumber: import("arktype/out/attributes.js").Default<number, number>;
+            minimumSpecial: import("arktype/out/attributes.js").Default<number, number>;
+        };
+    };
+}, {}>;
+export type PasswordStrategyPayload = typeof PasswordStrategyPayloadSchema.inferOut;
+export declare const InsertPasswordStrategyPayloadSchema: import("arktype/out/methods/object.js").ObjectType<{
+    type: "password";
+    label: string;
+    status: import("arktype/out/attributes.js").Default<"enabled" | "disabled", "enabled">;
+    id?: string | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    settings?: {
+        passwordPolicy: {
+            minimumLength: import("arktype/out/attributes.js").Default<number, number>;
+            maximumLength: import("arktype/out/attributes.js").Default<number, number>;
+            minimumCapital: import("arktype/out/attributes.js").Default<number, number>;
+            minimumLower: import("arktype/out/attributes.js").Default<number, number>;
+            minimumNumber: import("arktype/out/attributes.js").Default<number, number>;
+            minimumSpecial: import("arktype/out/attributes.js").Default<number, number>;
+        };
+    } | undefined;
+}, {}>;
+export type InsertPasswordStrategyInput = typeof InsertPasswordStrategyPayloadSchema.inferIn;
+export type InsertPasswordStrategyPayload = typeof InsertPasswordStrategyPayloadSchema.inferOut;
+export declare const UpdatePasswordStrategyPayloadSchema: import("arktype/out/methods/object.js").ObjectType<{
+    type: "password";
+    label?: string | undefined;
+    status?: "enabled" | "disabled" | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    settings?: {
+        passwordPolicy: {
+            minimumLength: import("arktype/out/attributes.js").Default<number, number>;
+            maximumLength: import("arktype/out/attributes.js").Default<number, number>;
+            minimumCapital: import("arktype/out/attributes.js").Default<number, number>;
+            minimumLower: import("arktype/out/attributes.js").Default<number, number>;
+            minimumNumber: import("arktype/out/attributes.js").Default<number, number>;
+            minimumSpecial: import("arktype/out/attributes.js").Default<number, number>;
+        };
+    } | undefined;
+}, {}>;
+export type UpdatePasswordStrategyInput = typeof UpdatePasswordStrategyPayloadSchema.inferIn;
+export type UpdatePasswordStrategyPayload = typeof UpdatePasswordStrategyPayloadSchema.inferOut;
+export declare const ForgotPasswordSchema: import("arktype/out/methods/object.js").ObjectType<{
+    identifier?: string | undefined;
+    identifierType?: "email" | "phoneNumber" | undefined;
+}, {}>;
+export declare const VerifyPasswordSchema: import("arktype/out/methods/object.js").ObjectType<{
+    password: string;
+    identifier?: string | undefined;
+    identifierType?: "email" | "phoneNumber" | undefined;
+}, {}>;
+//# sourceMappingURL=password.d.ts.map

package/dist/cjs/authentication/strategies/schema/types/password.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"password.d.ts","sourceRoot":"","sources":["../../../../../../src/authentication/strategies/schema/types/password.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,sBAAsB;;;;;;;CAOlC,CAAC;AAMF,eAAO,MAAM,oBAAoB;;;;;;;MAO/B,CAAC;AAMH,eAAO,MAAM,sCAAsC;;;;;;;;;;;MAEjD,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;MAEjC,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,OAAO,sBAAsB,CAAC,OAAO,CAAC;AAC/E,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAEtE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;MAEG,CAAC;AAC9C,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC;AAEhD,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;MAM5C,CAAC;AACL,MAAM,MAAM,2BAA2B,GACrC,OAAO,mCAAmC,CAAC,OAAO,CAAC;AACrD,MAAM,MAAM,6BAA6B,GACvC,OAAO,mCAAmC,CAAC,QAAQ,CAAC;AAEtD,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;MAI9C,CAAC;AACH,MAAM,MAAM,2BAA2B,GACrC,OAAO,mCAAmC,CAAC,OAAO,CAAC;AACrD,MAAM,MAAM,6BAA6B,GACvC,OAAO,mCAAmC,CAAC,QAAQ,CAAC;AAEtD,eAAO,MAAM,oBAAoB;;;MAG/B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;MAI/B,CAAC"}

package/dist/cjs/authentication/strategies/schema/types/password.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerifyPasswordSchema = exports.ForgotPasswordSchema = exports.UpdatePasswordStrategyPayloadSchema = exports.InsertPasswordStrategyPayloadSchema = exports.PasswordStrategyPayloadSchema = exports.PasswordStrategySchema = exports.PasswordStrategySettingsPropertySchema = exports.PasswordPolicySchema = exports.PasswordPolicyDefaults = void 0;
+const arktype_1 = require("arktype");
+const schema_js_1 = require("../../../../identity/schema.js");
+const base_js_1 = require("../base.js");
+exports.PasswordPolicyDefaults = {
+    minimumLength: 8,
+    maximumLength: 36,
+    minimumCapital: 1,
+    minimumLower: 1,
+    minimumNumber: 1,
+    minimumSpecial: 1,
+};
+const TypeSchema = (0, arktype_1.type)({
+    type: "'password'",
+});
+exports.PasswordPolicySchema = (0, arktype_1.type)({
+    minimumLength: arktype_1.type.number.default(exports.PasswordPolicyDefaults.minimumLength),
+    maximumLength: arktype_1.type.number.default(exports.PasswordPolicyDefaults.maximumLength),
+    minimumCapital: arktype_1.type.number.default(exports.PasswordPolicyDefaults.minimumCapital),
+    minimumLower: arktype_1.type.number.default(exports.PasswordPolicyDefaults.minimumLower),
+    minimumNumber: arktype_1.type.number.default(exports.PasswordPolicyDefaults.minimumNumber),
+    minimumSpecial: arktype_1.type.number.default(exports.PasswordPolicyDefaults.minimumSpecial),
+});
+const SettingsSchema = (0, arktype_1.type)({
+    passwordPolicy: exports.PasswordPolicySchema,
+});
+exports.PasswordStrategySettingsPropertySchema = (0, arktype_1.type)({
+    settings: SettingsSchema,
+});
+exports.PasswordStrategySchema = base_js_1.BaseStrategySchema.and(TypeSchema).and({
+    settings: SettingsSchema,
+});
+exports.PasswordStrategyPayloadSchema = base_js_1.BaseStrategyPayloadSchema.and(TypeSchema).and(exports.PasswordStrategySettingsPropertySchema);
+exports.InsertPasswordStrategyPayloadSchema = TypeSchema.and(base_js_1.BaseInsertStrategyPayloadSchema)
+    .and(TypeSchema)
+    .and({
+    settings: SettingsSchema.optional(),
+});
+exports.UpdatePasswordStrategyPayloadSchema = TypeSchema.and(base_js_1.BaseUpdateStrategyPayloadSchema).and({
+    settings: SettingsSchema.optional(),
+});
+exports.ForgotPasswordSchema = (0, arktype_1.type)({
+    identifier: (0, arktype_1.type)('string').optional(),
+    identifierType: schema_js_1.IdentityIdentifierSchema.optional(),
+});
+exports.VerifyPasswordSchema = (0, arktype_1.type)({
+    password: (0, arktype_1.type)('string'),
+    identifier: (0, arktype_1.type)('string').optional(),
+    identifierType: schema_js_1.IdentityIdentifierSchema.optional(),
+});

package/dist/cjs/authentication/strategies/schema/types/totp.d.ts

@@ -0,0 +1,110 @@
+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/out/methods/object.js").ObjectType<{
+    digits: import("arktype/out/attributes.js").Default<6 | 7 | 8, 6>;
+    period: import("arktype/out/attributes.js").Default<15 | 30 | 60, 30>;
+    algorithm: import("arktype/out/attributes.js").Default<string, string>;
+}, {}>;
+export type TOTPStrategySettings = typeof TOTPStrategySettingsSchema.inferOut;
+export declare const TOTPStrategySettingsPropertySchema: import("arktype/out/methods/object.js").ObjectType<{
+    settings: {
+        digits: import("arktype/out/attributes.js").Default<6 | 7 | 8, 6>;
+        period: import("arktype/out/attributes.js").Default<15 | 30 | 60, 30>;
+        algorithm: import("arktype/out/attributes.js").Default<string, string>;
+    };
+}, {}>;
+export type TOTPStrategySettingsProperty = typeof TOTPStrategySettingsPropertySchema.inferOut;
+export declare const TOTPStrategySchema: import("arktype/out/methods/object.js").ObjectType<{
+    id: string;
+    status: import("arktype/out/attributes.js").Default<"enabled" | "disabled", "enabled">;
+    label: string;
+    createdAt: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>);
+    updatedAt: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>);
+    deletedAt?: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>) | undefined;
+    deactivatedAt?: Date | ((In: string) => import("arktype/out/attributes.js").To<Date>) | undefined;
+    metadata: (In: import("arktype/out/attributes.js").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
+    type: "totp";
+    settings: {
+        digits: import("arktype/out/attributes.js").Default<6 | 7 | 8, 6>;
+        period: import("arktype/out/attributes.js").Default<15 | 30 | 60, 30>;
+        algorithm: import("arktype/out/attributes.js").Default<string, string>;
+    };
+}, {}>;
+export type TOTPStrategyProperties = typeof TOTPStrategySchema.inferIn;
+export type TOTPStrategy = typeof TOTPStrategySchema.inferOut;
+export declare const TOTPStrategyPayloadSchema: import("arktype/out/methods/object.js").ObjectType<{
+    status: "enabled" | "disabled";
+    label: string;
+    createdAt: (In: string | Date) => import("arktype").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype").Out<string>;
+    deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    type: "totp";
+    settings: {
+        digits: import("arktype/out/attributes.js").Default<6 | 7 | 8, 6>;
+        period: import("arktype/out/attributes.js").Default<15 | 30 | 60, 30>;
+        algorithm: import("arktype/out/attributes.js").Default<string, string>;
+    };
+}, {}>;
+export type TOTPStrategyPayload = typeof TOTPStrategyPayloadSchema.inferOut;
+export declare const InsertTOTPStrategyPayloadSchema: import("arktype/out/methods/object.js").ObjectType<{
+    type: "totp";
+    label: string;
+    status: import("arktype/out/attributes.js").Default<"enabled" | "disabled", "enabled">;
+    id?: string | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    settings?: {
+        digits: import("arktype/out/attributes.js").Default<6 | 7 | 8, 6>;
+        period: import("arktype/out/attributes.js").Default<15 | 30 | 60, 30>;
+        algorithm: import("arktype/out/attributes.js").Default<string, string>;
+    } | undefined;
+}, {}>;
+export type InsertTOTPStrategyInput = typeof InsertTOTPStrategyPayloadSchema.inferIn;
+export type InsertTOTPStrategyPayload = typeof InsertTOTPStrategyPayloadSchema.inferOut;
+export declare const UpdateTOTPStrategyPayloadSchema: import("arktype/out/methods/object.js").ObjectType<{
+    type: "totp";
+    label?: string | undefined;
+    status?: "enabled" | "disabled" | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    settings?: {
+        digits: import("arktype/out/attributes.js").Default<6 | 7 | 8, 6>;
+        period: import("arktype/out/attributes.js").Default<15 | 30 | 60, 30>;
+        algorithm: import("arktype/out/attributes.js").Default<string, string>;
+    } | undefined;
+}, {}>;
+export type UpdateTOTPStrategyInput = typeof UpdateTOTPStrategyPayloadSchema.inferIn;
+export type UpdateTOTPStrategyPayload = typeof UpdateTOTPStrategyPayloadSchema.inferOut;
+export declare const RegisterTOTPSchema: import("arktype/out/methods/object.js").ObjectType<{
+    uri: string;
+    token: string;
+}, {}>;
+export declare const VerifyTOTPSchema: import("arktype/out/methods/object.js").ObjectType<{
+    token: string;
+}, {}>;
+//# sourceMappingURL=totp.d.ts.map

package/dist/cjs/authentication/strategies/schema/types/totp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"totp.d.ts","sourceRoot":"","sources":["../../../../../../src/authentication/strategies/schema/types/totp.ts"],"names":[],"mappings":"AAQA,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,kBAAkB;;;;;;;;;;;;;;;MAE7B,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,OAAO,kBAAkB,CAAC,OAAO,CAAC;AACvE,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,QAAQ,CAAC;AAE9D,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;MAEG,CAAC;AAC1C,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAE5E,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;MAMxC,CAAC;AACL,MAAM,MAAM,uBAAuB,GACjC,OAAO,+BAA+B,CAAC,OAAO,CAAC;AACjD,MAAM,MAAM,yBAAyB,GACnC,OAAO,+BAA+B,CAAC,QAAQ,CAAC;AAElD,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;MAI1C,CAAC;AACH,MAAM,MAAM,uBAAuB,GACjC,OAAO,+BAA+B,CAAC,OAAO,CAAC;AACjD,MAAM,MAAM,yBAAyB,GACnC,OAAO,+BAA+B,CAAC,QAAQ,CAAC;AAElD,eAAO,MAAM,kBAAkB;;;MAO7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;MAI3B,CAAC"}

package/dist/cjs/authentication/strategies/schema/types/totp.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerifyTOTPSchema = exports.RegisterTOTPSchema = exports.UpdateTOTPStrategyPayloadSchema = exports.InsertTOTPStrategyPayloadSchema = exports.TOTPStrategyPayloadSchema = exports.TOTPStrategySchema = exports.TOTPStrategySettingsPropertySchema = exports.TOTPStrategySettingsSchema = exports.TOTPAlgorithm = exports.DEFAULT_PERIOD = exports.DEFAULT_DIGITS = void 0;
+const arktype_1 = require("arktype");
+const base_js_1 = require("../base.js");
+exports.DEFAULT_DIGITS = 6;
+exports.DEFAULT_PERIOD = 30;
+const TypeSchema = (0, arktype_1.type)({
+    type: "'totp'",
+});
+exports.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',
+};
+exports.TOTPStrategySettingsSchema = (0, arktype_1.type)({
+    digits: arktype_1.type.enumerated(6, 7, 8).default(exports.DEFAULT_DIGITS),
+    period: arktype_1.type.enumerated(15, 30, 60).default(exports.DEFAULT_PERIOD),
+    algorithm: arktype_1.type
+        .enumerated(exports.TOTPAlgorithm.SHA1, exports.TOTPAlgorithm.SHA224, exports.TOTPAlgorithm.SHA256, exports.TOTPAlgorithm.SHA384, exports.TOTPAlgorithm.SHA512, exports.TOTPAlgorithm['SHA3-224'], exports.TOTPAlgorithm['SHA3-256'], exports.TOTPAlgorithm['SHA3-384'], exports.TOTPAlgorithm['SHA3-512'])
+        .default(exports.TOTPAlgorithm.DEFAULT),
+});
+exports.TOTPStrategySettingsPropertySchema = (0, arktype_1.type)({
+    settings: exports.TOTPStrategySettingsSchema,
+});
+exports.TOTPStrategySchema = base_js_1.BaseStrategySchema.and(TypeSchema).and({
+    settings: exports.TOTPStrategySettingsSchema,
+});
+exports.TOTPStrategyPayloadSchema = base_js_1.BaseStrategyPayloadSchema.and(TypeSchema).and(exports.TOTPStrategySettingsPropertySchema);
+exports.InsertTOTPStrategyPayloadSchema = TypeSchema.and(base_js_1.BaseInsertStrategyPayloadSchema)
+    .and(TypeSchema)
+    .and({
+    settings: exports.TOTPStrategySettingsSchema.optional(),
+});
+exports.UpdateTOTPStrategyPayloadSchema = TypeSchema.and(base_js_1.BaseUpdateStrategyPayloadSchema).and({
+    settings: exports.TOTPStrategySettingsSchema.optional(),
+});
+exports.RegisterTOTPSchema = (0, arktype_1.type)({
+    uri: (0, arktype_1.type)('string.url').configure({
+        message: 'An authenticator uri is required',
+    }),
+    token: (0, arktype_1.type)('string').configure({
+        message: 'An authenticator token is required',
+    }),
+});
+exports.VerifyTOTPSchema = (0, arktype_1.type)({
+    token: (0, arktype_1.type)('string').configure({
+        message: 'An authenticator token is required',
+    }),
+});

package/dist/cjs/authentication/utils.d.ts

@@ -0,0 +1,13 @@
+export declare const Model: {
+    readonly Strategy: {
+        readonly UIDPrefix: "stg";
+        readonly TYPE: "Strategy";
+    };
+    readonly Session: {
+        readonly UIDPrefix: "ssn";
+        readonly TYPE: "Session";
+    };
+};
+export declare function generateStrategyId(): string;
+export declare function generateSessionId(): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/cjs/authentication/utils.d.ts.map

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

package/dist/cjs/authentication/utils.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = void 0;
+exports.generateStrategyId = generateStrategyId;
+exports.generateSessionId = generateSessionId;
+const ksuid_1 = __importDefault(require("ksuid"));
+exports.Model = {
+    Strategy: {
+        UIDPrefix: 'stg',
+        TYPE: 'Strategy',
+    },
+    Session: {
+        UIDPrefix: 'ssn',
+        TYPE: 'Session',
+    },
+};
+function generateStrategyId() {
+    return `${exports.Model.Strategy.UIDPrefix}_${ksuid_1.default.randomSync().string}`;
+}
+function generateSessionId() {
+    return `${exports.Model.Session.UIDPrefix}_${ksuid_1.default.randomSync().string}`;
+}

package/dist/cjs/authentication/utils.test.d.ts

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

package/dist/cjs/authentication/utils.test.d.ts.map

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

package/dist/cjs/authentication/utils.test.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const utils_js_1 = require("./utils.js");
+(0, vitest_1.describe)('Authentication Utils', () => {
+    (0, vitest_1.describe)('Model constants', () => {
+        (0, vitest_1.test)('should have correct Strategy model properties', () => {
+            (0, vitest_1.expect)(utils_js_1.Model.Strategy.UIDPrefix).toBe('stg');
+            (0, vitest_1.expect)(utils_js_1.Model.Strategy.TYPE).toBe('Strategy');
+        });
+        (0, vitest_1.test)('should have correct Session model properties', () => {
+            (0, vitest_1.expect)(utils_js_1.Model.Session.UIDPrefix).toBe('ssn');
+            (0, vitest_1.expect)(utils_js_1.Model.Session.TYPE).toBe('Session');
+        });
+        (0, vitest_1.test)('should be readonly (const assertion)', () => {
+            // Test that the Model object is properly typed as const
+            (0, vitest_1.expect)(typeof utils_js_1.Model).toBe('object');
+            (0, vitest_1.expect)(Object.isFrozen(utils_js_1.Model)).toBe(false); // const assertion doesn't freeze at runtime
+        });
+    });
+    (0, vitest_1.describe)('generateStrategyId', () => {
+        (0, vitest_1.test)('should generate ID with correct prefix', () => {
+            const id = (0, utils_js_1.generateStrategyId)();
+            (0, vitest_1.expect)(id).toMatch(/^stg_/);
+        });
+        (0, vitest_1.test)('should generate ID with correct format', () => {
+            const id = (0, utils_js_1.generateStrategyId)();
+            // Should match: prefix + underscore + KSUID (27 characters)
+            (0, vitest_1.expect)(id).toMatch(/^stg_[A-Za-z0-9]{27}$/);
+        });
+        (0, vitest_1.test)('should generate unique IDs on multiple calls', () => {
+            const id1 = (0, utils_js_1.generateStrategyId)();
+            const id2 = (0, utils_js_1.generateStrategyId)();
+            const id3 = (0, utils_js_1.generateStrategyId)();
+            (0, vitest_1.expect)(id1).not.toBe(id2);
+            (0, vitest_1.expect)(id2).not.toBe(id3);
+            (0, vitest_1.expect)(id1).not.toBe(id3);
+        });
+        (0, vitest_1.test)('should generate IDs with correct total length', () => {
+            const id = (0, utils_js_1.generateStrategyId)();
+            // prefix (3) + underscore (1) + KSUID (27) = 31 characters
+            (0, vitest_1.expect)(id.length).toBe(31);
+        });
+        (0, vitest_1.test)('should generate IDs that start with strategy prefix', () => {
+            const ids = Array.from({ length: 10 }, () => (0, utils_js_1.generateStrategyId)());
+            for (const id of ids) {
+                (0, vitest_1.expect)(id.startsWith('stg_')).toBe(true);
+            }
+        });
+        (0, vitest_1.test)('should generate KSUID-compatible format', () => {
+            const id = (0, utils_js_1.generateStrategyId)();
+            const ksuidPart = id.substring(4); // Remove 'stg_'
+            // KSUID should be 27 characters of base62
+            (0, vitest_1.expect)(ksuidPart.length).toBe(27);
+            (0, vitest_1.expect)(ksuidPart).toMatch(/^[A-Za-z0-9]{27}$/);
+        });
+        (0, vitest_1.test)('should be deterministic in format but random in content', () => {
+            const ids = Array.from({ length: 100 }, () => (0, utils_js_1.generateStrategyId)());
+            // All should have same format
+            for (const id of ids) {
+                (0, vitest_1.expect)(id).toMatch(/^stg_[A-Za-z0-9]{27}$/);
+            }
+            // All should be unique
+            const uniqueIds = new Set(ids);
+            (0, vitest_1.expect)(uniqueIds.size).toBe(100);
+        });
+    });
+    (0, vitest_1.describe)('generateSessionId', () => {
+        (0, vitest_1.test)('should generate ID with correct prefix', () => {
+            const id = (0, utils_js_1.generateSessionId)();
+            (0, vitest_1.expect)(id).toMatch(/^ssn_/);
+        });
+        (0, vitest_1.test)('should generate ID with correct format', () => {
+            const id = (0, utils_js_1.generateSessionId)();
+            // Should match: prefix + underscore + KSUID (27 characters)
+            (0, vitest_1.expect)(id).toMatch(/^ssn_[A-Za-z0-9]{27}$/);
+        });
+        (0, vitest_1.test)('should generate unique IDs on multiple calls', () => {
+            const id1 = (0, utils_js_1.generateSessionId)();
+            const id2 = (0, utils_js_1.generateSessionId)();
+            const id3 = (0, utils_js_1.generateSessionId)();
+            (0, vitest_1.expect)(id1).not.toBe(id2);
+            (0, vitest_1.expect)(id2).not.toBe(id3);
+            (0, vitest_1.expect)(id1).not.toBe(id3);
+        });
+        (0, vitest_1.test)('should generate IDs with correct total length', () => {
+            const id = (0, utils_js_1.generateSessionId)();
+            // prefix (3) + underscore (1) + KSUID (27) = 31 characters
+            (0, vitest_1.expect)(id.length).toBe(31);
+        });
+        (0, vitest_1.test)('should generate IDs that start with session prefix', () => {
+            const ids = Array.from({ length: 10 }, () => (0, utils_js_1.generateSessionId)());
+            for (const id of ids) {
+                (0, vitest_1.expect)(id.startsWith('ssn_')).toBe(true);
+            }
+        });
+        (0, vitest_1.test)('should generate KSUID-compatible format', () => {
+            const id = (0, utils_js_1.generateSessionId)();
+            const ksuidPart = id.substring(4); // Remove 'ssn_'
+            // KSUID should be 27 characters of base62
+            (0, vitest_1.expect)(ksuidPart.length).toBe(27);
+            (0, vitest_1.expect)(ksuidPart).toMatch(/^[A-Za-z0-9]{27}$/);
+        });
+        (0, vitest_1.test)('should be deterministic in format but random in content', () => {
+            const ids = Array.from({ length: 100 }, () => (0, utils_js_1.generateSessionId)());
+            // All should have same format
+            for (const id of ids) {
+                (0, vitest_1.expect)(id).toMatch(/^ssn_[A-Za-z0-9]{27}$/);
+            }
+            // All should be unique
+            const uniqueIds = new Set(ids);
+            (0, vitest_1.expect)(uniqueIds.size).toBe(100);
+        });
+    });
+    (0, vitest_1.describe)('ID generation comparison', () => {
+        (0, vitest_1.test)('should generate different formats for strategy vs session', () => {
+            const strategyId = (0, utils_js_1.generateStrategyId)();
+            const sessionId = (0, utils_js_1.generateSessionId)();
+            (0, vitest_1.expect)(strategyId.startsWith('stg_')).toBe(true);
+            (0, vitest_1.expect)(sessionId.startsWith('ssn_')).toBe(true);
+            (0, vitest_1.expect)(strategyId).not.toBe(sessionId);
+        });
+        (0, vitest_1.test)('should maintain format consistency across generators', () => {
+            const strategyIds = Array.from({ length: 10 }, () => (0, utils_js_1.generateStrategyId)());
+            const sessionIds = Array.from({ length: 10 }, () => (0, utils_js_1.generateSessionId)());
+            // All strategy IDs should have same prefix
+            for (const id of strategyIds) {
+                (0, vitest_1.expect)(id.startsWith('stg_')).toBe(true);
+                (0, vitest_1.expect)(id.length).toBe(31);
+            }
+            // All session IDs should have same prefix
+            for (const id of sessionIds) {
+                (0, vitest_1.expect)(id.startsWith('ssn_')).toBe(true);
+                (0, vitest_1.expect)(id.length).toBe(31);
+            }
+            // No overlap between the two sets
+            const allIds = [...strategyIds, ...sessionIds];
+            const uniqueIds = new Set(allIds);
+            (0, vitest_1.expect)(uniqueIds.size).toBe(20);
+        });
+    });
+});

package/dist/cjs/authorization/index.d.ts

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

package/dist/cjs/authorization/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/authorization/index.ts"],"names":[],"mappings":"AACA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AAGxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAElC,cAAc,aAAa,CAAC"}

package/dist/cjs/authorization/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Permissions
+__exportStar(require("./permissions/resources.js"), exports);
+__exportStar(require("./permissions/schema.js"), exports);
+// Roles
+__exportStar(require("./roles/resources.js"), exports);
+__exportStar(require("./roles/schema.js"), exports);
+__exportStar(require("./schema.js"), exports);

package/dist/cjs/authorization/permissions/resources.d.ts

@@ -0,0 +1,20 @@
+import type { MondoIdentity } from '../../common/resources/init.js';
+import { type PaginationCollection } from '../../common/schema/collection.js';
+import type { Pagination } from '../../common/schema/pagination.js';
+import { type InsertPermissionInput, type Permission, type UpdatePermissionInput } from './schema.js';
+export declare class PermissionResources {
+    private readonly instance;
+    constructor(instance: MondoIdentity);
+    static buildPath(id?: string): string;
+    listItems(pagination?: Pagination): Promise<PaginationCollection<Permission>>;
+    getItem(id: string): Promise<Permission>;
+    insertItem(item: InsertPermissionInput): Promise<Permission>;
+    updateItem(id: string, item: UpdatePermissionInput): Promise<Permission>;
+    deleteItem(id: string): Promise<Permission>;
+}
+export declare function listPermissions(instance: MondoIdentity, pagination?: Pagination): Promise<PaginationCollection<Permission>>;
+export declare function getPermission(instance: MondoIdentity, id: string): Promise<Permission>;
+export declare function insertPermission(instance: MondoIdentity, item: InsertPermissionInput): Promise<Permission>;
+export declare function updatePermission(instance: MondoIdentity, id: string, item: UpdatePermissionInput): Promise<Permission>;
+export declare function deletePermission(instance: MondoIdentity, id: string): Promise<Permission>;
+//# sourceMappingURL=resources.d.ts.map

package/dist/cjs/authorization/permissions/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../../src/authorization/permissions/resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAWpE,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EACL,KAAK,qBAAqB,EAE1B,KAAK,UAAU,EAEf,KAAK,qBAAqB,EAE3B,MAAM,aAAa,CAAC;AAIrB,qBAAa,mBAAmB;IACX,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAE3D,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IAQ9B,SAAS,CACd,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAC;IAIrC,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAIxC,UAAU,CAAC,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC,UAAU,CAAC;IAI5D,UAAU,CACf,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,qBAAqB,GAC1B,OAAO,CAAC,UAAU,CAAC;IAIf,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;CAGnD;AAED,wBAAsB,eAAe,CACnC,QAAQ,EAAE,aAAa,EACvB,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAC,CAW3C;AAED,wBAAsB,aAAa,CACjC,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,UAAU,CAAC,CASrB;AAED,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,qBAAqB,GAC1B,OAAO,CAAC,UAAU,CAAC,CAYrB;AAED,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,qBAAqB,GAC1B,OAAO,CAAC,UAAU,CAAC,CAYrB;AAED,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,UAAU,CAAC,CASrB"}