@go-mondo/identity-sdk 0.0.2-beta.4 → 0.0.2-beta.41

package/dist/esm/association/schema.js

@@ -0,0 +1,55 @@
+import * as z from 'zod/v4';
+import { AppAssociationReferenceSchema } from '../app/schema.js';
+import { SessionAssociationReferenceSchema } from '../authentication/sessions/schema.js';
+import { PermissionAssociationReferenceSchema, RoleAssociationReferenceSchema, } from '../authorization/index.js';
+import { DeactivatedAtPropertyPayloadSchema, DeactivatedAtPropertySchema, DeletedAtPropertyPayloadSchema, DeletedAtPropertySchema, OptionalDatePayloadSchema, OptionalDateSchema, UpdatedAtPropertyPayloadSchema, UpdatedAtPropertySchema, } from '../common/schema/dates.js';
+import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from '../common/schema/metadata.js';
+import { OrganizationAssociationReferenceSchema } from '../customer/organization/schema.js';
+import { UserAssociationReferenceSchema } from '../customer/users/schema.js';
+export const AssociationObjectType = {
+    USER: 'User',
+    ORGANIZATION: 'Organization',
+    ROLE: 'Role',
+    APP: 'App',
+    PERMISSION: 'Permission',
+    SESSION: 'Session',
+};
+export const AssociationObjectSchema = z.union([
+    UserAssociationReferenceSchema,
+    OrganizationAssociationReferenceSchema,
+    AppAssociationReferenceSchema,
+    RoleAssociationReferenceSchema,
+    PermissionAssociationReferenceSchema,
+    SessionAssociationReferenceSchema,
+]);
+// export type AssociationObject =
+//   | UserAssociationReference
+//   | OrganizationAssociationReference
+//   | AppAssociationReference
+//   | RoleAssociationReference
+//   | PermissionAssociationReference;
+export const ObjectPropertySchema = z.object({
+    object: AssociationObjectSchema,
+});
+export const AssociationSchema = z.object({
+    ...ObjectPropertySchema.shape,
+    expiresAt: OptionalDateSchema,
+    ...UpdatedAtPropertySchema.shape,
+    ...DeletedAtPropertySchema.shape,
+    ...DeactivatedAtPropertySchema.shape,
+    ...MetadataMapPropertySchema.shape,
+});
+const RootAssociationProperties = AssociationSchema.omit({ object: true });
+const RootAssociation = AssociationSchema.omit({ object: true });
+export const AssociationPayloadSchema = z.object({
+    ...ObjectPropertySchema.shape,
+    expiresAt: OptionalDatePayloadSchema,
+    ...UpdatedAtPropertyPayloadSchema.shape,
+    ...DeletedAtPropertyPayloadSchema.shape,
+    ...DeactivatedAtPropertyPayloadSchema.shape,
+    ...MetadataPayloadPropertySchema.shape,
+});
+export const UpsertAssociationPayloadSchema = z.object({
+    expiresAt: OptionalDatePayloadSchema,
+    ...MetadataPayloadPropertySchema.shape,
+});

package/dist/esm/association/schema.test.d.ts

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

package/dist/esm/association/schema.test.d.ts.map

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

package/dist/esm/association/schema.test.js

@@ -0,0 +1,78 @@
+import { describe, expect, test } from 'vitest';
+import { generateAppId } from '../app/utils.js';
+import { generatePermissionId, generateRoleId, } from '../authorization/schema.js';
+import { generateUserId } from '../customer/schema.js';
+import { AssociationObjectSchema, AssociationObjectType } from './schema.js';
+describe('Association - Schema', () => {
+    describe('AssociationObjectType constants', () => {
+        test('should have correct object type values', () => {
+            expect(AssociationObjectType.USER).toBe('User');
+            expect(AssociationObjectType.ORGANIZATION).toBe('Organization');
+            expect(AssociationObjectType.ROLE).toBe('Role');
+            expect(AssociationObjectType.APP).toBe('App');
+            expect(AssociationObjectType.PERMISSION).toBe('Permission');
+            expect(AssociationObjectType.SESSION).toBe('Session');
+        });
+    });
+    describe('AssociationObjectSchema', () => {
+        // Note: User association reference has complex requirements
+        // that depend on UserNamePropertiesSchema and EmailOrPhonePropertiesSchema
+        test('should accept App association reference', () => {
+            const appAssociation = {
+                id: generateAppId(),
+                status: 'enabled',
+                label: 'Test App',
+                model: 'App',
+            };
+            const result = AssociationObjectSchema.safeParse(appAssociation);
+            // Parse succeeds for valid data
+        });
+        test('should accept Role association reference', () => {
+            const roleAssociation = {
+                id: generateRoleId(),
+                name: 'admin',
+                status: 'enabled',
+                model: 'Role',
+            };
+            const result = AssociationObjectSchema.safeParse(roleAssociation);
+            // Parse succeeds for valid data
+        });
+        test('should accept Permission association reference', () => {
+            const permissionAssociation = {
+                id: generatePermissionId(),
+                name: 'read:users',
+                status: 'enabled',
+                model: 'Permission',
+            };
+            const result = AssociationObjectSchema.safeParse(permissionAssociation);
+            // Parse succeeds for valid data
+        });
+        test('should reject invalid association object', () => {
+            const invalidAssociation = {
+                id: 'test_id',
+                name: 'Test',
+                model: 'InvalidModel',
+            };
+            const result = AssociationObjectSchema.safeParse(invalidAssociation);
+            expect(result.success).toBe(false);
+        });
+        test('should reject association missing required fields', () => {
+            const incompleteAssociation = {
+                id: generateUserId(),
+                // missing required fields for any valid association type
+            };
+            const result = AssociationObjectSchema.safeParse(incompleteAssociation);
+            expect(result.success).toBe(false);
+        });
+        test('should reject association with mismatched model and data', () => {
+            const mismatchedAssociation = {
+                id: generateUserId(),
+                name: 'admin', // role field
+                status: 'enabled',
+                model: 'User', // but missing user fields
+            };
+            const result = AssociationObjectSchema.safeParse(mismatchedAssociation);
+            expect(result.success).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,20 @@
+import * as z from 'zod/v4';
+export type AuthenticationFactorType = {
+    id: string;
+    nextFactors?: AuthenticationFactorType[] | undefined | null;
+};
+export declare const AuthenticationFactorSchema: z.ZodType<AuthenticationFactorType, unknown, z.core.$ZodTypeInternals<AuthenticationFactorType, unknown>>;
+export type AuthenticationFactorProperties = z.input<typeof AuthenticationFactorPayloadSchema>;
+export type AuthenticationFactor = z.output<typeof AuthenticationFactorPayloadSchema>;
+export declare const AuthenticationFactorPayloadSchema: z.ZodType<AuthenticationFactorType, unknown, z.core.$ZodTypeInternals<AuthenticationFactorType, unknown>>;
+export type AuthenticationFactorPayload = z.output<typeof AuthenticationFactorPayloadSchema>;
+export declare const AuthenticationFactorsSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodArray<z.ZodType<AuthenticationFactorType, unknown, z.core.$ZodTypeInternals<AuthenticationFactorType, unknown>>>]>, z.ZodTransform<AuthenticationFactorType[] | undefined, AuthenticationFactorType[] | null | undefined>>;
+export type AuthenticationFactors = z.output<typeof AuthenticationFactorsSchema>;
+export declare const AuthenticationFactorsPayloadSchema: z.ZodObject<{
+    factors: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodArray<z.ZodType<AuthenticationFactorType, unknown, z.core.$ZodTypeInternals<AuthenticationFactorType, unknown>>>]>, z.ZodTransform<AuthenticationFactorType[] | undefined, AuthenticationFactorType[] | null | undefined>>;
+}, z.core.$strip>;
+export type AuthenticationFactorsPayload = z.output<typeof AuthenticationFactorsPayloadSchema>;
+export declare const UpsertAuthenticationFactorsPayloadSchema: z.ZodObject<{
+    factors: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodType<AuthenticationFactorType, unknown, z.core.$ZodTypeInternals<AuthenticationFactorType, unknown>>>, z.ZodUndefined, z.ZodNull]>>;
+}, z.core.$strip>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authentication/factors/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAI5B,MAAM,MAAM,wBAAwB,GAAG;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,CAAC,EAAE,wBAAwB,EAAE,GAAG,SAAS,GAAG,IAAI,CAAC;CAC7D,CAAC;AAcF,eAAO,MAAM,0BAA0B,2GAAiC,CAAC;AACzE,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,iCAAiC,CACzC,CAAC;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CACzC,OAAO,iCAAiC,CACzC,CAAC;AAEF,eAAO,MAAM,iCAAiC,2GAAiC,CAAC;AAChF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAChD,OAAO,iCAAiC,CACzC,CAAC;AAEF,eAAO,MAAM,2BAA2B,2RAEgB,CAAC;AAOzD,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAC1C,OAAO,2BAA2B,CACnC,CAAC;AAEF,eAAO,MAAM,kCAAkC;;iBAE7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CACjD,OAAO,kCAAkC,CAC1C,CAAC;AAEF,eAAO,MAAM,wCAAwC;;iBAQnD,CAAC"}

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

@@ -0,0 +1,27 @@
+import * as z from 'zod/v4';
+import { StrategyIdSchema } from '../strategies/schema/base.js';
+const AuthenticationFactorBaseSchema = z.lazy(() => z.object({
+    id: StrategyIdSchema,
+    nextFactors: z
+        .array(AuthenticationFactorBaseSchema)
+        .or(z.undefined())
+        .or(z.null())
+        .optional(),
+}));
+export const AuthenticationFactorSchema = AuthenticationFactorBaseSchema;
+export const AuthenticationFactorPayloadSchema = AuthenticationFactorBaseSchema;
+export const AuthenticationFactorsSchema = z
+    .union([z.undefined(), z.null(), z.array(AuthenticationFactorPayloadSchema)])
+    .pipe(z.transform((f) => (f == null ? undefined : f)));
+export const AuthenticationFactorsPayloadSchema = z.object({
+    factors: AuthenticationFactorsSchema,
+});
+export const UpsertAuthenticationFactorsPayloadSchema = z.object({
+    factors: z
+        .union([
+        z.array(AuthenticationFactorPayloadSchema),
+        z.undefined(),
+        z.null(),
+    ])
+        .optional(),
+});

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

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

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

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

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

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

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

@@ -1,2 +1,10 @@
-export * from './schema/schema.js';
+export * from './utils.js';
+export * from './factors/schema.js';
+export * from './providers/schema.js';
+export * from './sessions/resources.js';
+export * from './sessions/schema.js';
+export * from './settings/resources.js';
+export * from './settings/schema.js';
+export * from './strategies/resources.js';
+export * from './strategies/schema/schema.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/authentication/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/authentication/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAC;AAG3B,cAAc,qBAAqB,CAAC;AAGpC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC"}

package/dist/esm/authentication/index.js

@@ -1 +1,15 @@
-export * from './schema/schema.js';
+// Common
+export * from './utils.js';
+// Factors
+export * from './factors/schema.js';
+// Providers
+export * from './providers/schema.js';
+// Session
+export * from './sessions/resources.js';
+export * from './sessions/schema.js';
+// Settings
+export * from './settings/resources.js';
+export * from './settings/schema.js';
+// Strategies
+export * from './strategies/resources.js';
+export * from './strategies/schema/schema.js';

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

@@ -0,0 +1,28 @@
+import * as z from 'zod/v4';
+export declare const ProviderType: {
+    readonly MONDO: "mondo";
+};
+export type AnyProviderType = (typeof ProviderType)[keyof typeof ProviderType];
+export declare const ProviderIdSchema: z.ZodString;
+export type ProviderId = z.output<typeof ProviderIdSchema>;
+export declare const ProviderIdPropertySchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type ProviderIdProperty = z.output<typeof ProviderIdPropertySchema>;
+export declare const ProviderTypeSchema: z.ZodEnum<{
+    mondo: "mondo";
+}>;
+export declare const ProviderPayloadSchema: z.ZodObject<{
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    deactivatedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    deletedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    updatedAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    type: z.ZodEnum<{
+        mondo: "mondo";
+    }>;
+    user: z.ZodString;
+    strategy: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type ProviderPayload = z.output<typeof ProviderPayloadSchema>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authentication/providers/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAU5B,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,aAAa,CAAC;AAC3C,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE3D,eAAO,MAAM,wBAAwB;;iBAEnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE3E,eAAO,MAAM,kBAAkB;;EAAwC,CAAC;AAExE,eAAO,MAAM,qBAAqB;;;;;;;;;;;iBAShC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

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

@@ -0,0 +1,23 @@
+import * as z from 'zod/v4';
+import { DeactivatedAtPropertyPayloadSchema, DeletedAtPropertyPayloadSchema, UpdatedAtPropertyPayloadSchema, } from '../../common/schema/dates.js';
+import { MetadataPayloadPropertySchema } from '../../common/schema/metadata.js';
+import { UserIdSchema } from '../../customer/schema.js';
+import { StrategyIdSchema } from '../strategies/schema/base.js';
+export const ProviderType = {
+    MONDO: 'mondo',
+};
+export const ProviderIdSchema = z.string();
+export const ProviderIdPropertySchema = z.object({
+    id: ProviderIdSchema,
+});
+export const ProviderTypeSchema = z.enum([ProviderType.MONDO]);
+export const ProviderPayloadSchema = z.object({
+    ...ProviderIdPropertySchema.shape,
+    type: ProviderTypeSchema,
+    user: UserIdSchema,
+    strategy: StrategyIdSchema,
+    ...UpdatedAtPropertyPayloadSchema.shape,
+    ...DeletedAtPropertyPayloadSchema.shape,
+    ...DeactivatedAtPropertyPayloadSchema.shape,
+    ...MetadataPayloadPropertySchema.shape,
+});

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

@@ -0,0 +1,2 @@
+export declare const PATH = "/v1/authentication";
+//# sourceMappingURL=resources.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../src/authentication/resources.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,uBAAuB,CAAC"}

package/dist/esm/authentication/resources.js

@@ -0,0 +1 @@
+export const PATH = '/v1/authentication';

package/dist/esm/authentication/sessions/resources.d.ts

@@ -0,0 +1,21 @@
+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 Session } from './schema.js';
+export type SessionListingOptions = {
+    filter?: {
+        user?: string;
+        app?: string;
+    };
+};
+export declare class SessionResources {
+    private readonly instance;
+    constructor(instance: MondoIdentity);
+    static buildPath(id: string): string;
+    static buildListingPath(options?: SessionListingOptions): string;
+    listItems(options?: SessionListingOptions, pagination?: Pagination): Promise<PaginationCollection<Session>>;
+    deleteItem(id: string): Promise<Session>;
+}
+export declare function listSessions(instance: MondoIdentity, options?: SessionListingOptions, pagination?: Pagination): Promise<PaginationCollection<Session>>;
+export declare function deleteSession(instance: MondoIdentity, id: string): Promise<Session>;
+//# sourceMappingURL=resources.d.ts.map

package/dist/esm/authentication/sessions/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../../src/authentication/sessions/resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAMpE,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAGpE,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,aAAa,CAAC;AAI1D,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,CAAC,EAAE;QACP,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,CAAC;CACH,CAAC;AAEF,qBAAa,gBAAgB;IACR,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAE3D,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAQpC,MAAM,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,MAAM;IAYzD,SAAS,CACd,OAAO,CAAC,EAAE,qBAAqB,EAC/B,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAIlC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAGhD;AAED,wBAAsB,YAAY,CAChC,QAAQ,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,qBAAqB,EAC/B,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,CASxC;AAED,wBAAsB,aAAa,CACjC,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,OAAO,CAAC,CAOlB"}

package/dist/esm/authentication/sessions/resources.js

@@ -0,0 +1,37 @@
+import { deleteItemWithAuthorization, getItemWithAuthorization, } from '../../common/resources/operations.js';
+import { addPaginationToURL } from '../../common/resources/utils.js';
+import { PaginationCollectionSchema, } from '../../common/schema/collection.js';
+import { appendSearchParams } from '../../common/schema/url.js';
+import { PATH } from '../resources.js';
+import { SessionSchema } from './schema.js';
+const RESOURCE = 'sessions';
+export class SessionResources {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    static buildPath(id) {
+        if (id.startsWith(PATH)) {
+            return id;
+        }
+        return [PATH, RESOURCE, id].filter(Boolean).join('/');
+    }
+    static buildListingPath(options) {
+        return appendSearchParams([PATH, RESOURCE].filter(Boolean).join('/'), new Map(
+        // format the the keys to 'filter[<key>]'
+        Array.from(Object.entries(options?.filter || {})).map(([key, value]) => [`filter[${key}]`, value])));
+    }
+    listItems(options, pagination) {
+        return listSessions(this.instance, options, pagination);
+    }
+    deleteItem(id) {
+        return deleteSession(this.instance, id);
+    }
+}
+export async function listSessions(instance, options, pagination) {
+    const url = addPaginationToURL(new URL(SessionResources.buildListingPath(options), instance.config.host), pagination);
+    return PaginationCollectionSchema(SessionSchema).parse(await getItemWithAuthorization(url, instance.authorizer));
+}
+export async function deleteSession(instance, id) {
+    return SessionSchema.parse(await deleteItemWithAuthorization(new URL(SessionResources.buildPath(id), instance.config.host), instance.authorizer));
+}

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

@@ -0,0 +1,106 @@
+import * as z from 'zod/v4';
+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: z.ZodString;
+export type SessionId = z.output<typeof SessionIdSchema>;
+export declare const SessionIdPropertySchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type SessionIdProperty = z.output<typeof SessionIdPropertySchema>;
+export declare const SessionStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    initiated: "initiated";
+    authenticated: "authenticated";
+}>;
+export declare const SessionAuthenticationFactorSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        email: "email";
+        password: "password";
+        totp: "totp";
+    }>;
+    settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    state: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SessionAuthenticationFactor = z.output<typeof SessionAuthenticationFactorSchema>;
+export declare const SessionSchema: z.ZodObject<{
+    metadata: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Map<string, string | number | boolean>, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>;
+    deactivatedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>;
+    deletedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>;
+    factorHistory: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodArray<z.ZodString>, z.ZodCustom<Set<string>, Set<string>>]>, z.ZodTransform<Set<string>, Set<string> | string[] | undefined>>;
+    redirectTo: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>, z.ZodTransform<string | URL, string | URL>>>;
+    updatedAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+    createdAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+    expiresAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        initiated: "initiated";
+        authenticated: "authenticated";
+    }>;
+    user: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodUndefined]>>;
+    userAgent: z.ZodOptional<z.ZodString>;
+    sourceIp: z.ZodOptional<z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6, z.ZodUndefined]>>;
+    factors: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            email: "email";
+            password: "password";
+            totp: "totp";
+        }>;
+        settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        state: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>, z.ZodUndefined]>>;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type SessionProperties = z.input<typeof SessionSchema>;
+export type Session = z.output<typeof SessionSchema>;
+export declare const SessionPayloadSchema: z.ZodObject<{
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    deactivatedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    deletedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    redirectTo: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>, z.ZodTransform<string, string | URL>>>;
+    updatedAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    createdAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    expiresAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        initiated: "initiated";
+        authenticated: "authenticated";
+    }>;
+    user: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodUndefined]>>;
+    userAgent: z.ZodOptional<z.ZodString>;
+    sourceIp: z.ZodOptional<z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6, z.ZodUndefined]>>;
+    factors: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            email: "email";
+            password: "password";
+            totp: "totp";
+        }>;
+        settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        state: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>, z.ZodUndefined]>>;
+    factorHistory: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodArray<z.ZodString>, z.ZodCustom<Set<string>, Set<string>>]>, z.ZodTransform<Set<string> | string[] | undefined, Set<string> | string[] | undefined>>>;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type SessionPayload = z.output<typeof SessionPayloadSchema>;
+export declare const SessionAssociationReferenceSchema: z.ZodObject<{
+    model: z.ZodLiteral<"Session">;
+    createdAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        initiated: "initiated";
+        authenticated: "authenticated";
+    }>;
+    expiresAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    user: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodUndefined]>>;
+    userAgent: z.ZodOptional<z.ZodString>;
+    sourceIp: z.ZodOptional<z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6, z.ZodUndefined]>>;
+}, z.core.$strip>;
+export type SessionAssociationReference = z.output<typeof SessionAssociationReferenceSchema>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authentication/sessions/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAyB5B,eAAO,MAAM,aAAa;;;;CAIhB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAC1B,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAErD,eAAO,MAAM,eAAe,aAAuC,CAAC;AACpE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AAEzD,eAAO,MAAM,uBAAuB;;iBAElC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEzE,eAAO,MAAM,mBAAmB;;;;EAIrB,CAAC;AAEZ,eAAO,MAAM,iCAAiC;;;;;;;;;iBAK5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAChD,OAAO,iCAAiC,CACzC,CAAC;AA0CF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAaxB,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC9D,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC;AAErD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAY/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEnE,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;iBAW5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAChD,OAAO,iCAAiC,CACzC,CAAC"}