@kitledger/core 0.0.2 → 0.0.3

package/dist/accounts.d.ts

@@ -0,0 +1,44 @@
+import { InferInsertModel, InferSelectModel } from "drizzle-orm";
+import * as v from "valibot";
+import { InferOutput } from "valibot";
+import { KitledgerDb } from "./db.js";
+import { FilterOperationParameters, GetOperationResult } from "./db.js";
+import { accounts } from "./schema.js";
+import { ValidationFailure, ValidationSuccess } from "./validation.js";
+export declare enum BalanceType {
+    DEBIT = "debit",
+    CREDIT = "credit"
+}
+export declare const AccountCreateSchema: v.ObjectSchema<{
+    readonly ref_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 64, undefined>]>;
+    readonly alt_id: v.NullishSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 64, undefined>]>, null>;
+    readonly balance_type: v.EnumSchema<typeof BalanceType, undefined>;
+    readonly ledger_id: v.StringSchema<undefined>;
+    readonly parent_id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 64, undefined>]>;
+    readonly meta: v.NullishSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.DateSchema<undefined>, v.BooleanSchema<undefined>, v.NullSchema<undefined>], undefined>, undefined>, null>;
+    readonly active: v.NullishSchema<v.BooleanSchema<undefined>, true>;
+    readonly created_at: v.OptionalSchema<v.DateSchema<undefined>, undefined>;
+    readonly updated_at: v.OptionalSchema<v.NullableSchema<v.DateSchema<undefined>, undefined>, undefined>;
+}, undefined>;
+export type AccountInsert = InferInsertModel<typeof accounts>;
+export type Account = InferSelectModel<typeof accounts>;
+export type AccountCreateData = InferOutput<typeof AccountCreateSchema>;
+/**
+ * Procedurally builds and executes a filter query for accounts based on the provided parameters.
+ * @param params
+ * @returns
+ */
+export declare function filterAccounts(db: KitledgerDb, params: FilterOperationParameters): Promise<GetOperationResult<Account>>;
+/**
+ * Finds the parent account by ID or ref_id or alt_id.
+ * Returns the ID of the parent account if found, otherwise returns null.
+ */
+export declare function findParentAccount(db: KitledgerDb, parentId: string, ledgerId?: string | null): Promise<Account | null>;
+/**
+ * Finds the ledger by ID or ref_id or alt_id.
+ * @param ledgerId
+ * @returns
+ */
+export declare function findLedgerId(db: KitledgerDb, ledgerId: string): Promise<string | null>;
+export declare function createAccount(db: KitledgerDb, data: AccountCreateData): Promise<ValidationSuccess<Account> | ValidationFailure<AccountCreateData>>;

package/dist/accounts.js

@@ -0,0 +1,221 @@
+import { and, eq, or, sql } from "drizzle-orm";
+import { v7 } from "uuid";
+import * as v from "valibot";
+import { ANY, defaultLimit, defaultOffset, maxLimit, parseBooleanFilterValue, } from "./db.js";
+import { accounts, ledgers } from "./schema.js";
+import { parseValibotIssues, } from "./validation.js";
+export var BalanceType;
+(function (BalanceType) {
+    BalanceType["DEBIT"] = "debit";
+    BalanceType["CREDIT"] = "credit";
+})(BalanceType || (BalanceType = {}));
+export const AccountCreateSchema = v.object({
+    ref_id: v.pipe(v.string(), v.maxLength(64)),
+    alt_id: v.nullish(v.pipe(v.string(), v.maxLength(64)), null),
+    balance_type: v.enum(BalanceType),
+    ledger_id: v.string(),
+    parent_id: v.optional(v.nullable(v.string())),
+    name: v.pipe(v.string(), v.nonEmpty(), v.maxLength(64)),
+    meta: v.nullish(v.record(v.string(), v.union([v.string(), v.number(), v.date(), v.boolean(), v.null()])), null),
+    active: v.nullish(v.boolean(), true),
+    created_at: v.optional(v.date()),
+    updated_at: v.optional(v.nullable(v.date())),
+});
+/**
+ * Procedurally builds and executes a filter query for accounts based on the provided parameters.
+ * @param params
+ * @returns
+ */
+export async function filterAccounts(db, params) {
+    const { limit = defaultLimit, offset = defaultOffset, ...filters } = params;
+    const filterConditions = [];
+    let ledgerId = null;
+    for (const [key, value] of Object.entries(filters)) {
+        if (key === accounts.id.name && String(value).length > 0) {
+            filterConditions.push(eq(accounts.id, String(value)));
+        }
+        if (key === accounts.ref_id.name && String(value).length > 0) {
+            filterConditions.push(eq(accounts.ref_id, String(value)));
+        }
+        if (key === accounts.alt_id.name && String(value).length > 0) {
+            filterConditions.push(eq(accounts.alt_id, String(value)));
+        }
+        if (key === accounts.balance_type.name && String(value).length > 0) {
+            filterConditions.push(eq(accounts.balance_type, String(value)));
+        }
+        if (key === accounts.name.name && String(value).length > 0) {
+            filterConditions.push(sql `${accounts.name} ILIKE ${"%" + String(value) + "%"}`);
+        }
+        if (key === accounts.ledger_id.name && String(value).length > 0) {
+            ledgerId = await findLedgerId(db, String(value));
+            if (ledgerId) {
+                filterConditions.push(eq(accounts.ledger_id, ledgerId));
+            }
+        }
+        if (key === accounts.active.name && String(value).length > 0) {
+            if (value === ANY) {
+                continue;
+            }
+            const booleanValue = parseBooleanFilterValue(String(value));
+            if (booleanValue !== null) {
+                filterConditions.push(eq(accounts.active, booleanValue));
+            }
+        }
+        if (key === accounts.parent_id.name && String(value).length > 0) {
+            const parentAccount = await findParentAccount(db, String(value), null);
+            if (parentAccount) {
+                filterConditions.push(eq(accounts.parent_id, parentAccount.id));
+            }
+            else {
+                filterConditions.push(eq(sql `${accounts.parent_id}::text`, value));
+            }
+        }
+    }
+    // Default to only active accounts if no active filter is provided
+    if (!Object.keys(filters).includes(accounts.active.name)) {
+        filterConditions.push(eq(accounts.active, true));
+    }
+    const results = await db
+        .select()
+        .from(accounts)
+        .where(and(...filterConditions))
+        .limit(Math.min(limit, maxLimit))
+        .offset(offset);
+    return {
+        data: results,
+        limit: Math.min(limit, maxLimit),
+        offset: offset,
+        count: results.length,
+    };
+}
+/**
+ * Finds the parent account by ID or ref_id or alt_id.
+ * Returns the ID of the parent account if found, otherwise returns null.
+ */
+export async function findParentAccount(db, parentId, ledgerId) {
+    if (!parentId) {
+        return null;
+    }
+    const parent = await db.query.accounts.findFirst({
+        where: and(or(eq(sql `${accounts.id}::text`, parentId), eq(accounts.ref_id, parentId), eq(accounts.alt_id, parentId)), ledgerId ? eq(accounts.ledger_id, ledgerId) : undefined, eq(accounts.active, true)),
+    });
+    return parent ? parent : null;
+}
+/**
+ * Finds the ledger by ID or ref_id or alt_id.
+ * @param ledgerId
+ * @returns
+ */
+export async function findLedgerId(db, ledgerId) {
+    const ledger = await db.query.ledgers.findFirst({
+        where: and(or(eq(sql `${ledgers.id}::text`, ledgerId), eq(ledgers.ref_id, ledgerId), eq(ledgers.alt_id, ledgerId)), eq(ledgers.active, true)),
+        columns: { id: true },
+    });
+    return ledger ? ledger.id : null;
+}
+// ACTIONS
+async function refIdAlreadyExists(db, refId) {
+    const results = await db.query.accounts.findMany({
+        where: eq(accounts.ref_id, refId),
+        columns: { id: true },
+    });
+    return results.length > 0;
+}
+async function altIdAlreadyExists(db, altId) {
+    if (!altId) {
+        return false;
+    }
+    const results = await db.query.accounts.findMany({
+        where: eq(accounts.alt_id, altId),
+        columns: { id: true },
+    });
+    return results.length > 0;
+}
+async function validateAccountCreate(db, data) {
+    const result = v.safeParse(AccountCreateSchema, data);
+    let success = result.success;
+    if (!result.success) {
+        return { success: false, errors: parseValibotIssues(result.issues) };
+    }
+    const errors = [];
+    const [refIdError, altIdError, ledgerId] = await Promise.all([
+        refIdAlreadyExists(db, result.output.ref_id),
+        altIdAlreadyExists(db, result.output.alt_id ?? null),
+        findLedgerId(db, result.output.ledger_id),
+    ]);
+    if (refIdError) {
+        success = false;
+        errors.push({
+            type: "data",
+            path: "ref_id",
+            message: "Ref ID already exists.",
+        });
+    }
+    if (altIdError) {
+        success = false;
+        errors.push({
+            type: "data",
+            path: "alt_id",
+            message: "Alt ID already exists.",
+        });
+    }
+    if (ledgerId) {
+        result.output.ledger_id = ledgerId;
+    }
+    else {
+        success = false;
+        errors.push({
+            type: "data",
+            path: "ledger_id",
+            message: "Invalid ledger ID.",
+        });
+    }
+    if (result.output.parent_id) {
+        const parentAccount = await findParentAccount(db, result.output.parent_id, result.output.ledger_id);
+        if (parentAccount) {
+            result.output.parent_id = result.output.parent_id ? parentAccount.id : null;
+            result.output.balance_type = parentAccount.balance_type;
+        }
+        else {
+            success = false;
+            errors.push({
+                type: "data",
+                path: "parent_id",
+                message: "Invalid parent account ID.",
+            });
+        }
+    }
+    return { success, data: result.output, errors: errors };
+}
+export async function createAccount(db, data) {
+    const validation = await validateAccountCreate(db, data);
+    if (!validation.success || !validation.data) {
+        return {
+            success: false,
+            data: data,
+            errors: validation.errors,
+        };
+    }
+    const insertData = {
+        id: v7(),
+        ...validation.data,
+    };
+    const result = await db.insert(accounts).values(insertData).returning();
+    if (result.length === 0) {
+        return {
+            success: false,
+            data: validation.data,
+            errors: [
+                {
+                    type: "data",
+                    path: null,
+                    message: "Failed to create account.",
+                },
+            ],
+        };
+    }
+    return {
+        success: true,
+        data: result[0],
+    };
+}

package/dist/auth.d.ts

@@ -0,0 +1,34 @@
+import { InferInsertModel, InferSelectModel } from "drizzle-orm";
+import { type KitledgerDb } from "./db.js";
+import { api_tokens, permission_assignments, permissions, roles, system_permissions, user_roles, users } from "./schema.js";
+export type ApiTokenInsert = InferInsertModel<typeof api_tokens>;
+export type ApiToken = InferSelectModel<typeof api_tokens>;
+export type PermissionAssignmentInsert = InferInsertModel<typeof permission_assignments>;
+export type PermissionAssignment = InferSelectModel<typeof permission_assignments>;
+export type PermissionInsert = InferInsertModel<typeof permissions>;
+export type Permission = InferSelectModel<typeof permissions>;
+export type RoleInsert = InferInsertModel<typeof roles>;
+export type Role = InferSelectModel<typeof roles>;
+export type SystemPermissionInsert = InferInsertModel<typeof system_permissions>;
+export type SystemPermission = InferSelectModel<typeof system_permissions>;
+export type UserInsert = InferInsertModel<typeof users>;
+export type User = InferSelectModel<typeof users>;
+export type UserRoleInsert = InferInsertModel<typeof user_roles>;
+export type UserRole = InferSelectModel<typeof user_roles>;
+export type AppUser = Omit<User, "password_hash"> & {
+    roles: Role[];
+    permissions: Permission[];
+    system_permissions: SystemPermission[];
+};
+export declare const SYSTEM_ADMIN_PERMISSION = "KL_SYSTEM_ADMIN";
+export declare function startSession(db: KitledgerDb, userId: string, sessionConfig: SessionConfigOptions): Promise<string>;
+export declare function createToken(db: KitledgerDb, userId: string, name?: string | null): Promise<string>;
+export type AuthConfigOptions = {
+    secret: string;
+    pastSecrets: string[];
+    jwtAlgorithm: "HS256";
+};
+export type SessionConfigOptions = {
+    cookieName: string;
+    ttl: number;
+};

package/dist/auth.js

@@ -0,0 +1,24 @@
+import { v7 } from "uuid";
+import { api_tokens, sessions, } from "./schema.js";
+const SYSTEM_PERMISSION_PREFIX = "KL_";
+export const SYSTEM_ADMIN_PERMISSION = `${SYSTEM_PERMISSION_PREFIX}SYSTEM_ADMIN`;
+export async function startSession(db, userId, sessionConfig) {
+    const sessionId = v7();
+    await db.insert(sessions).values({
+        id: sessionId,
+        user_id: userId,
+        expires_at: new Date(Date.now() + sessionConfig.ttl * 1000),
+        created_at: new Date(),
+    });
+    return sessionId;
+}
+export async function createToken(db, userId, name) {
+    const tokenId = v7();
+    await db.insert(api_tokens).values({
+        id: tokenId,
+        user_id: userId,
+        name: name ?? "API Token",
+        revoked_at: null,
+    });
+    return tokenId;
+}

package/dist/config.d.ts

@@ -0,0 +1,28 @@
+type CorsConfig = {
+    origin: string | string[];
+    allowMethods?: string[];
+    allowHeaders?: string[];
+    maxAge?: number;
+    credentials?: boolean;
+    exposeHeaders?: string[];
+};
+type ServerConfig = {
+    port: number;
+    cors: CorsConfig;
+};
+type WorkerConfig = {
+    poolSize: number;
+    taskTimeout: number;
+    maxQueueSize: number;
+};
+/**
+ * Export pre-assembled configuration values for the HTTP server.
+ * Values are a mix of environment variables and defaults.
+ */
+export declare const serverConfig: ServerConfig;
+/**
+ * Export pre-assembled configuration values for the worker pool.
+ * Values are a mix of environment variables and defaults.
+ */
+export declare const workerConfig: WorkerConfig;
+export {};

package/dist/config.js

@@ -0,0 +1,48 @@
+import { cpus } from "node:os";
+/**
+ * CORS configuration values and defaults.
+ */
+const corsDefaultHeaders = ["Content-Type", "Authorization", "X-Requested-With"];
+const corsAllowedHeaders = [
+    ...new Set([...corsDefaultHeaders, ...(process.env.KL_CORS_ALLOWED_HEADERS?.split(",") || [])]),
+];
+const corsAllowedMethods = ["GET", "POST", "PUT", "DELETE", "OPTIONS"];
+const corsAllowedOrigins = process.env.KL_CORS_ALLOWED_ORIGINS ? process.env.KL_CORS_ALLOWED_ORIGINS.split(",") : "*";
+const corsCredentials = false;
+const corsExposeHeaders = [];
+const corsMaxAge = parseInt(process.env.KL_CORS_MAX_AGE || "86400");
+/**
+ * Worker pool configuration values and defaults.
+ */
+const workerPoolSize = parseInt(process.env.KL_WORKER_POOL_SIZE || String(cpus().length)) || 1;
+const workerTaskTimeout = parseInt(process.env.KL_WORKER_TASK_TIMEOUT || "5000"); // Default to 5 seconds
+const workerMaxQueueSize = process.env.KL_WORKER_MAX_QUEUE_SIZE
+    ? parseInt(process.env.KL_WORKER_MAX_QUEUE_SIZE)
+    : Infinity;
+/*
+ * 3) Export the configuration objects.
+ */
+/**
+ * Export pre-assembled configuration values for the HTTP server.
+ * Values are a mix of environment variables and defaults.
+ */
+export const serverConfig = {
+    port: process.env.KL_SERVER_PORT ? parseInt(process.env.KL_SERVER_PORT) : 8888,
+    cors: {
+        origin: corsAllowedOrigins,
+        allowMethods: corsAllowedMethods,
+        allowHeaders: corsAllowedHeaders,
+        exposeHeaders: corsExposeHeaders,
+        credentials: corsCredentials,
+        maxAge: corsMaxAge,
+    },
+};
+/**
+ * Export pre-assembled configuration values for the worker pool.
+ * Values are a mix of environment variables and defaults.
+ */
+export const workerConfig = {
+    poolSize: workerPoolSize,
+    taskTimeout: workerTaskTimeout,
+    maxQueueSize: workerMaxQueueSize,
+};

package/dist/crypto.d.ts

@@ -0,0 +1,2 @@
+export declare function hashPassword(input: string): Promise<string>;
+export declare function verifyPassword(hashStr: string, input: string): Promise<boolean>;

package/dist/crypto.js

@@ -0,0 +1,13 @@
+import { hash, verify } from "@node-rs/argon2";
+export function hashPassword(input) {
+    const hashOptions = {
+        type: 2, // argon2id
+        memoryCost: 65536, // 64 MiB
+        timeCost: 5, // 5 iterations
+        parallelism: 1,
+    };
+    return hash(input, hashOptions);
+}
+export function verifyPassword(hashStr, input) {
+    return verify(hashStr, input);
+}

package/dist/db.d.ts

@@ -0,0 +1,78 @@
+import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import * as v from "valibot";
+import * as schema from "./schema.js";
+type DbOptions = {
+    url: string;
+    ssl?: boolean;
+    max?: number;
+    migrations_table?: string;
+    migrations_schema?: string;
+};
+export type KitledgerDb = PostgresJsDatabase<typeof schema> & {
+    $client: postgres.Sql<{}>;
+};
+export declare function initializeDatabase(options: DbOptions): Promise<PostgresJsDatabase<typeof schema> & {
+    $client: postgres.Sql<{}>;
+}>;
+/**
+ * Common database helper for timestamps
+ */
+export declare const timestamps: {
+    created_at: import("drizzle-orm").NotNull<import("drizzle-orm").HasDefault<import("drizzle-orm/pg-core").PgTimestampBuilderInitial<"created_at">>>;
+    updated_at: import("drizzle-orm/pg-core").PgTimestampBuilderInitial<"updated_at">;
+};
+/**
+ * Supported operation types for get operations.
+ */
+export declare enum GetOperationType {
+    FILTER = "filter",
+    SEARCH = "search",
+    QUERY = "query"
+}
+/**
+ * Parameters for filter operations, including optional limit and offset.
+ */
+export type FilterOperationParameters = Record<string, string> & {
+    limit?: number;
+    offset?: number;
+};
+/**
+ * Result structure for get operations, including data array and optional limit and offset.
+ */
+export type GetOperationResult<T> = {
+    data: T[];
+    count: number;
+    limit?: number;
+    offset?: number;
+    errors?: {
+        field?: string;
+        message: string;
+    }[];
+};
+export type QueryResultRow = v.InferInput<typeof QueryResultRowSchema>;
+export declare const QueryResultRowSchema: v.RecordSchema<v.StringSchema<undefined>, v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.DateSchema<undefined>, v.NullSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.DateSchema<undefined>, v.NullSchema<undefined>], undefined>, undefined>], undefined>, undefined>;
+export declare const QueryResultSchema: v.ArraySchema<v.RecordSchema<v.StringSchema<undefined>, v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.DateSchema<undefined>, v.NullSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.DateSchema<undefined>, v.NullSchema<undefined>], undefined>, undefined>], undefined>, undefined>, undefined>;
+/**
+ * Utility function to parse boolean filter values from strings or booleans to be used in queries and filters.
+ * @param value
+ * @returns
+ */
+export declare function parseBooleanFilterValue(value: string | boolean): boolean | null;
+/**
+ * String constant representing a wildcard for boolean filters.
+ */
+export declare const ANY = "any";
+/**
+ * Default value for pagination limit.
+ */
+export declare const defaultLimit = 100;
+/**
+ * Maximum allowable value for pagination limit.
+ */
+export declare const maxLimit = 1000;
+/**
+ * Default value for pagination offset.
+ */
+export declare const defaultOffset = 0;
+export {};

package/dist/db.js

@@ -0,0 +1,86 @@
+import { timestamp } from "drizzle-orm/pg-core";
+import { drizzle } from "drizzle-orm/postgres-js";
+import { migrate } from "drizzle-orm/postgres-js/migrator";
+import * as v from "valibot";
+import * as schema from "./schema.js";
+async function runMigrations(db, migrationsTable, migrationsSchema) {
+    await migrate(db, {
+        migrationsFolder: "./migrations",
+        migrationsTable: migrationsTable,
+        migrationsSchema: migrationsSchema,
+    });
+}
+export async function initializeDatabase(options) {
+    const dbConfig = {
+        url: options.url,
+        ssl: options.ssl ? options.ssl : false,
+        max: options.max ? options.max : 10,
+    };
+    const db = drizzle({
+        connection: dbConfig,
+        schema: schema,
+    });
+    const migrationsTable = options.migrations_table || "schema_history";
+    const migrationsSchema = options.migrations_schema || "public";
+    await runMigrations(db, migrationsTable, migrationsSchema);
+    return db;
+}
+/**
+ * Common database helper for timestamps
+ */
+export const timestamps = {
+    created_at: timestamp("created_at", { mode: "date" }).defaultNow().notNull(),
+    updated_at: timestamp("updated_at", { mode: "date" }),
+};
+/**
+ * Supported operation types for get operations.
+ */
+export var GetOperationType;
+(function (GetOperationType) {
+    GetOperationType["FILTER"] = "filter";
+    GetOperationType["SEARCH"] = "search";
+    GetOperationType["QUERY"] = "query";
+})(GetOperationType || (GetOperationType = {}));
+export const QueryResultRowSchema = v.record(v.string(), v.union([
+    v.string(),
+    v.number(),
+    v.boolean(),
+    v.date(),
+    v.null(),
+    v.record(v.string(), v.union([v.string(), v.number(), v.boolean(), v.date(), v.null()])),
+]));
+export const QueryResultSchema = v.array(QueryResultRowSchema);
+/**
+ * Utility function to parse boolean filter values from strings or booleans to be used in queries and filters.
+ * @param value
+ * @returns
+ */
+export function parseBooleanFilterValue(value) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    const lowerValue = value.toLowerCase();
+    if (lowerValue === "true") {
+        return true;
+    }
+    if (lowerValue === "false") {
+        return false;
+    }
+    return null;
+}
+/**
+ * String constant representing a wildcard for boolean filters.
+ */
+export const ANY = "any";
+/**
+ * Default value for pagination limit.
+ */
+export const defaultLimit = 100;
+/**
+ * Maximum allowable value for pagination limit.
+ */
+export const maxLimit = 1000;
+/**
+ * Default value for pagination offset.
+ */
+export const defaultOffset = 0;

package/dist/factories.d.ts

@@ -0,0 +1,45 @@
+import { Account } from "./accounts.js";
+import { ApiToken, Permission, PermissionAssignment, Role, SystemPermission, User, UserRole } from "./auth.js";
+import { Ledger } from "./ledgers.js";
+/**
+ * A generic factory function to create an array of items.
+ * @param factory A function that creates a single item.
+ * @param count The number of items to create.
+ * @returns An array of created items.
+ */
+export declare const factory: <T>(factory: () => T, count: number) => T[];
+export declare class BaseFactory<T> {
+    private factory;
+    constructor(factory: () => T);
+    make(count: number): T[];
+}
+export declare class ApiTokenFactory extends BaseFactory<ApiToken> {
+    constructor();
+}
+export declare class PermissionFactory extends BaseFactory<Permission> {
+    constructor();
+}
+export declare class PermissionAssignmentFactory extends BaseFactory<PermissionAssignment> {
+    constructor();
+}
+export declare class RoleFactory extends BaseFactory<Role> {
+    constructor();
+}
+export declare class SessionFactory extends BaseFactory<string> {
+    constructor();
+}
+export declare class SystemPermissionFactory extends BaseFactory<SystemPermission> {
+    constructor();
+}
+export declare class UserFactory extends BaseFactory<User> {
+    constructor();
+}
+export declare class UserRoleFactory extends BaseFactory<UserRole> {
+    constructor();
+}
+export declare class LedgerFactory extends BaseFactory<Ledger> {
+    constructor();
+}
+export declare class AccountFactory extends BaseFactory<Account> {
+    constructor();
+}