@managemint-solutions/sdk 0.35.0 → 0.37.0

package/dist/leave/leave-requests.d.ts

@@ -0,0 +1,69 @@
+import type { MmsList } from '@managemint-solutions/entities/common';
+import type { LeavePeriod, LeaveRequestEntity } from '@managemint-solutions/entities/leave';
+import { LeaveRequestStatus, LeaveReviewDecision } from '@managemint-solutions/entities/leave/enum';
+import type { AuthContext } from '../auth';
+import { type AuditResource } from '../audit';
+import type { TypedSupabaseClient } from '../client';
+import type { GetLeaveRequestsDto } from './dto';
+/** A request as the api inserts it: the caller's own, with the days already counted. */
+export type CreateLeaveRequestRow = {
+    user_id: string;
+    leave_type_id: string;
+    start_date: string;
+    end_date: string;
+    is_half_day: boolean;
+    days: number;
+    reason: string | null;
+    status: LeaveRequestStatus;
+    /** Set on an auto-approved request; `reviewed_by` stays null to say nobody reviewed it. */
+    reviewed_at?: string | null;
+};
+/** The recounted fields of a pending request being edited. */
+export type UpdateLeaveRequestRow = {
+    leave_type_id: string;
+    start_date: string;
+    end_date: string;
+    is_half_day: boolean;
+    days: number;
+    reason: string | null;
+};
+export type ReviewLeaveRequestRow = {
+    status: LeaveReviewDecision;
+    reviewed_by: string;
+    review_note: string | null;
+};
+/** The lists share a filter set; `userIds` is the visibility the api resolved for the caller. */
+type ListOptions = {
+    userIds?: string[];
+};
+export declare class LeaveRequestsResource {
+    private readonly supabase;
+    private readonly auth;
+    private readonly table;
+    constructor(supabase: TypedSupabaseClient, auth: AuthContext, audit: AuditResource);
+    list(query: GetLeaveRequestsDto, options?: ListOptions): Promise<MmsList<LeaveRequestEntity>>;
+    getById(leaveRequestId: string): Promise<LeaveRequestEntity>;
+    /**
+     * Whether `userId` already has a live request touching any day of `start`..`end`. The readable
+     * half of the rule; the table's exclusion constraint is the half that survives a race.
+     */
+    overlaps(userId: string, start: string, end: string, excludeId?: string): Promise<boolean>;
+    /**
+     * The days of `userId`'s requests of `leaveTypeId` in `statuses` that start inside `period` -
+     * what an entitlement's balance is checked against. `excludeId` leaves out the request being
+     * edited or approved so it is not counted against itself.
+     */
+    sumDays(userId: string, leaveTypeId: string, period: LeavePeriod, statuses: LeaveRequestStatus[], excludeId?: string): Promise<number>;
+    create(input: CreateLeaveRequestRow): Promise<LeaveRequestEntity>;
+    /** Edits a request while it is still pending; null when it no longer is. */
+    update(leaveRequestId: string, input: UpdateLeaveRequestRow): Promise<LeaveRequestEntity | null>;
+    /**
+     * Approves or rejects a pending request. Resolves to null when the request was no longer
+     * pending - another reviewer got there first, or the requester cancelled - so the caller
+     * can say so instead of overwriting their decision.
+     */
+    review(leaveRequestId: string, input: ReviewLeaveRequestRow): Promise<LeaveRequestEntity | null>;
+    /** Cancels a pending or approved request; null when it was already closed. */
+    cancel(leaveRequestId: string, cancelledBy: string): Promise<LeaveRequestEntity | null>;
+}
+export {};

package/dist/leave/leave-requests.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaveRequestsResource = void 0;
+const enum_1 = require("@managemint-solutions/entities/audit-trail/enum");
+const enum_2 = require("@managemint-solutions/entities/leave/enum");
+const audit_1 = require("../audit");
+const errors_1 = require("../errors");
+const transforms_1 = require("../transforms");
+const LEAVE_REQUEST_SELECT = `
+        mms_id,
+        created_at,
+        created_by:user_profiles!created_by (*),
+        updated_at,
+        last_updated_by:user_profiles!last_updated_by (*),
+        user:user_profiles!user_id (*),
+        leave_type:leave_types!leave_type_id (
+          mms_id,
+          name
+        ),
+        start_date,
+        end_date,
+        is_half_day,
+        days,
+        reason,
+        status,
+        reviewed_by:user_profiles!reviewed_by (*),
+        reviewed_at,
+        review_note,
+        cancelled_by:user_profiles!cancelled_by (*),
+        cancelled_at
+      `;
+/** The statuses that hold days: a pending request reserves them, an approved one uses them. */
+const LIVE_STATUSES = [enum_2.LeaveRequestStatus.PENDING, enum_2.LeaveRequestStatus.APPROVED];
+class LeaveRequestsResource {
+    supabase;
+    auth;
+    table;
+    constructor(supabase, auth, audit) {
+        this.supabase = supabase;
+        this.auth = auth;
+        this.table = (0, audit_1.auditedTable)(supabase, auth, audit, {
+            table: 'leave_requests',
+            entityType: enum_1.AuditTrailEntityType.LEAVE_REQUESTS,
+        });
+    }
+    async list(query, options = {}) {
+        const page = query.page;
+        const pageSize = query.page_size;
+        const offset = (page - 1) * pageSize;
+        let requestsQuery = this.supabase
+            .from('leave_requests')
+            .select(LEAVE_REQUEST_SELECT, { count: 'estimated' })
+            .eq('organization_id', this.auth.organization_id)
+            .order('start_date', { ascending: false })
+            .order('created_at', { ascending: false })
+            .range(offset, offset + pageSize - 1);
+        if (options.userIds) {
+            requestsQuery = requestsQuery.in('user_id', options.userIds);
+        }
+        if (query.user_id) {
+            requestsQuery = requestsQuery.eq('user_id', query.user_id);
+        }
+        if (query.status) {
+            requestsQuery = requestsQuery.eq('status', query.status);
+        }
+        if (query.start_date_after) {
+            requestsQuery = requestsQuery.gte('start_date', query.start_date_after);
+        }
+        if (query.start_date_before) {
+            requestsQuery = requestsQuery.lte('start_date', query.start_date_before);
+        }
+        const { data, error, count } = await requestsQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (0, transforms_1.toMmsList)(data, page, pageSize, count);
+    }
+    async getById(leaveRequestId) {
+        const { data, error } = await this.supabase
+            .from('leave_requests')
+            .select(LEAVE_REQUEST_SELECT)
+            .eq('mms_id', leaveRequestId)
+            .eq('organization_id', this.auth.organization_id)
+            .single();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return data;
+    }
+    /**
+     * Whether `userId` already has a live request touching any day of `start`..`end`. The readable
+     * half of the rule; the table's exclusion constraint is the half that survives a race.
+     */
+    async overlaps(userId, start, end, excludeId) {
+        let overlapQuery = this.supabase
+            .from('leave_requests')
+            .select('mms_id', { count: 'exact', head: true })
+            .eq('organization_id', this.auth.organization_id)
+            .eq('user_id', userId)
+            .in('status', LIVE_STATUSES)
+            .lte('start_date', end)
+            .gte('end_date', start);
+        if (excludeId) {
+            overlapQuery = overlapQuery.neq('mms_id', excludeId);
+        }
+        const { count, error } = await overlapQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (count ?? 0) > 0;
+    }
+    /**
+     * The days of `userId`'s requests of `leaveTypeId` in `statuses` that start inside `period` -
+     * what an entitlement's balance is checked against. `excludeId` leaves out the request being
+     * edited or approved so it is not counted against itself.
+     */
+    async sumDays(userId, leaveTypeId, period, statuses, excludeId) {
+        let daysQuery = this.supabase
+            .from('leave_requests')
+            .select('days')
+            .eq('organization_id', this.auth.organization_id)
+            .eq('user_id', userId)
+            .eq('leave_type_id', leaveTypeId)
+            .in('status', statuses)
+            .gte('start_date', period.period_start)
+            .lte('start_date', period.period_end);
+        if (excludeId) {
+            daysQuery = daysQuery.neq('mms_id', excludeId);
+        }
+        const { data, error } = await daysQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (data ?? []).reduce((total, row) => total + Number(row.days), 0);
+    }
+    async create(input) {
+        const row = await this.table.insert({
+            ...input,
+            reviewed_at: input.reviewed_at ?? null,
+            organization_id: this.auth.organization_id,
+            created_by: this.auth.mms_id,
+            created_at: new Date().toISOString(),
+        });
+        return this.getById(row.mms_id);
+    }
+    /** Edits a request while it is still pending; null when it no longer is. */
+    async update(leaveRequestId, input) {
+        const row = await this.table.updateWhere(leaveRequestId, (query) => query.eq('status', enum_2.LeaveRequestStatus.PENDING), {
+            ...input,
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        return row ? this.getById(leaveRequestId) : null;
+    }
+    /**
+     * Approves or rejects a pending request. Resolves to null when the request was no longer
+     * pending - another reviewer got there first, or the requester cancelled - so the caller
+     * can say so instead of overwriting their decision.
+     */
+    async review(leaveRequestId, input) {
+        const now = new Date().toISOString();
+        const row = await this.table.updateWhere(leaveRequestId, (query) => query.eq('status', enum_2.LeaveRequestStatus.PENDING), {
+            status: input.status,
+            reviewed_by: input.reviewed_by,
+            reviewed_at: now,
+            review_note: input.review_note,
+            last_updated_by: this.auth.mms_id,
+            updated_at: now,
+        });
+        return row ? this.getById(leaveRequestId) : null;
+    }
+    /** Cancels a pending or approved request; null when it was already closed. */
+    async cancel(leaveRequestId, cancelledBy) {
+        const now = new Date().toISOString();
+        const row = await this.table.updateWhere(leaveRequestId, (query) => query.in('status', LIVE_STATUSES), {
+            status: enum_2.LeaveRequestStatus.CANCELLED,
+            cancelled_by: cancelledBy,
+            cancelled_at: now,
+            last_updated_by: this.auth.mms_id,
+            updated_at: now,
+        });
+        return row ? this.getById(leaveRequestId) : null;
+    }
+}
+exports.LeaveRequestsResource = LeaveRequestsResource;

package/dist/leave/leave-types.d.ts

@@ -0,0 +1,21 @@
+import type { LeaveTypeEntity } from '@managemint-solutions/entities/leave';
+import type { AuthContext } from '../auth';
+import { type AuditResource } from '../audit';
+import type { TypedSupabaseClient } from '../client';
+import type { CreateLeaveTypeDto, GetLeaveTypesDto, UpdateLeaveTypeDto } from './dto';
+export declare class LeaveTypesResource {
+    private readonly supabase;
+    private readonly auth;
+    private readonly table;
+    constructor(supabase: TypedSupabaseClient, auth: AuthContext, audit: AuditResource);
+    /** Every type by name; `active` narrows to one side of the flag. Small enough not to page. */
+    list(query: GetLeaveTypesDto): Promise<LeaveTypeEntity[]>;
+    getById(leaveTypeId: string): Promise<LeaveTypeEntity>;
+    create(input: CreateLeaveTypeDto): Promise<LeaveTypeEntity>;
+    update(leaveTypeId: string, input: UpdateLeaveTypeDto): Promise<LeaveTypeEntity>;
+    /**
+     * Hard delete. The entitlement and request foreign keys are `on delete restrict`, so a type
+     * that has ever been used fails here with the SDK's 409 - deactivate it instead.
+     */
+    remove(leaveTypeId: string): Promise<void>;
+}

package/dist/leave/leave-types.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaveTypesResource = void 0;
+const enum_1 = require("@managemint-solutions/entities/audit-trail/enum");
+const audit_1 = require("../audit");
+const errors_1 = require("../errors");
+// The public contract is the shared LeaveTypeEntity from @managemint-solutions/entities; the
+// casts at the returns declare the shape the select string produces (the columns are defined in
+// the api's supabase/migrations).
+const LEAVE_TYPE_SELECT = `
+        mms_id,
+        created_at,
+        created_by:user_profiles!created_by (*),
+        updated_at,
+        last_updated_by:user_profiles!last_updated_by (*),
+        name,
+        description,
+        default_days,
+        is_paid,
+        requires_approval,
+        active
+      `;
+class LeaveTypesResource {
+    supabase;
+    auth;
+    table;
+    constructor(supabase, auth, audit) {
+        this.supabase = supabase;
+        this.auth = auth;
+        this.table = (0, audit_1.auditedTable)(supabase, auth, audit, {
+            table: 'leave_types',
+            entityType: enum_1.AuditTrailEntityType.LEAVE_TYPES,
+        });
+    }
+    /** Every type by name; `active` narrows to one side of the flag. Small enough not to page. */
+    async list(query) {
+        let typesQuery = this.supabase
+            .from('leave_types')
+            .select(LEAVE_TYPE_SELECT)
+            .eq('organization_id', this.auth.organization_id)
+            .order('name');
+        if (query.active !== undefined && query.active !== null) {
+            typesQuery = typesQuery.eq('active', query.active);
+        }
+        const { data, error } = await typesQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return data;
+    }
+    async getById(leaveTypeId) {
+        const { data, error } = await this.supabase
+            .from('leave_types')
+            .select(LEAVE_TYPE_SELECT)
+            .eq('mms_id', leaveTypeId)
+            .eq('organization_id', this.auth.organization_id)
+            .single();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return data;
+    }
+    async create(input) {
+        const row = await this.table.insert({
+            name: input.name,
+            description: input.description,
+            default_days: input.default_days,
+            is_paid: input.is_paid,
+            requires_approval: input.requires_approval,
+            organization_id: this.auth.organization_id,
+            created_by: this.auth.mms_id,
+            created_at: new Date().toISOString(),
+        });
+        return this.getById(row.mms_id);
+    }
+    async update(leaveTypeId, input) {
+        await this.table.update(leaveTypeId, {
+            name: input.name,
+            description: input.description,
+            default_days: input.default_days,
+            is_paid: input.is_paid,
+            requires_approval: input.requires_approval,
+            active: input.active,
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        return this.getById(leaveTypeId);
+    }
+    /**
+     * Hard delete. The entitlement and request foreign keys are `on delete restrict`, so a type
+     * that has ever been used fails here with the SDK's 409 - deactivate it instead.
+     */
+    async remove(leaveTypeId) {
+        await this.table.remove(leaveTypeId);
+    }
+}
+exports.LeaveTypesResource = LeaveTypesResource;

package/dist/leave/working-days.d.ts

@@ -0,0 +1,29 @@
+import type { LeavePeriod } from '@managemint-solutions/entities/leave';
+/**
+ * Where "today" is read for the cancel rule. Organizations carry no time zone yet, and every
+ * customer is South African; this is the one place to change when a column arrives.
+ */
+export declare const LEAVE_TIME_ZONE = "Africa/Johannesburg";
+/** The `YYYY-MM-DD` of a `Date`'s UTC calendar day. */
+export declare const toIsoDate: (date: Date) => string;
+/** Today's calendar date in `LEAVE_TIME_ZONE`. */
+export declare const todayInJohannesburg: (now?: Date) => string;
+/** Every calendar date from `start` to `end` inclusive; empty when `end` is before `start`. */
+export declare const eachDate: (start: string, end: string) => string[];
+/** Monday to Friday and not one of the organization's holidays. */
+export declare const isWorkingDay: (isoDate: string, holidays: ReadonlySet<string>) => boolean;
+/**
+ * The days a request is worth: the working days from `start` to `end` inclusive, halved for a
+ * half day. A half day is only meaningful on a single working day, so it yields 0.5 there and 0
+ * on a weekend or holiday - the caller rejects a zero either way.
+ */
+export declare const countWorkingDays: (start: string, end: string, holidays: ReadonlySet<string>, isHalfDay?: boolean) => number;
+/** The day before the same date next year - the end of a period that starts on `isoDate`. */
+export declare const addOneYearMinusDay: (isoDate: string) => string;
+/**
+ * The leave year containing `date` for an organization whose year starts on the first of
+ * `startMonth` (1-12, `organizations.leave_calendar_start_month`). A March start puts
+ * 2026-02-10 in the year that began 2025-03-01.
+ */
+export declare const leavePeriodFor: (date: string, startMonth: number) => LeavePeriod;
+export declare const isWithinPeriod: (date: string, period: LeavePeriod) => boolean;

package/dist/leave/working-days.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWithinPeriod = exports.leavePeriodFor = exports.addOneYearMinusDay = exports.countWorkingDays = exports.isWorkingDay = exports.eachDate = exports.todayInJohannesburg = exports.toIsoDate = exports.LEAVE_TIME_ZONE = void 0;
+// The calendar arithmetic behind leave: which days of a request count, and which leave year a
+// date belongs to. Pure functions over `YYYY-MM-DD` strings - the columns are `date`, so a
+// request never carries a time and nothing here depends on the caller's clock zone.
+/**
+ * Where "today" is read for the cancel rule. Organizations carry no time zone yet, and every
+ * customer is South African; this is the one place to change when a column arrives.
+ */
+exports.LEAVE_TIME_ZONE = 'Africa/Johannesburg';
+/** Saturday and Sunday. Not configurable yet - a working-week setting is a later feature. */
+const WEEKEND_DAYS = new Set([0, 6]);
+const pad = (value) => String(value).padStart(2, '0');
+/** A `Date` at UTC midnight of a `YYYY-MM-DD` string (a longer ISO string is cut to its date). */
+const parseIsoDate = (value) => {
+    const [year, month, day] = value.slice(0, 10).split('-').map(Number);
+    return new Date(Date.UTC(year, month - 1, day));
+};
+/** The `YYYY-MM-DD` of a `Date`'s UTC calendar day. */
+const toIsoDate = (date) => `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}`;
+exports.toIsoDate = toIsoDate;
+/** Today's calendar date in `LEAVE_TIME_ZONE`. */
+const todayInJohannesburg = (now = new Date()) => 
+// en-CA is the locale whose short date is already YYYY-MM-DD.
+new Intl.DateTimeFormat('en-CA', {
+    timeZone: exports.LEAVE_TIME_ZONE,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+}).format(now);
+exports.todayInJohannesburg = todayInJohannesburg;
+/** Every calendar date from `start` to `end` inclusive; empty when `end` is before `start`. */
+const eachDate = (start, end) => {
+    const dates = [];
+    const last = end.slice(0, 10);
+    for (const cursor = parseIsoDate(start); (0, exports.toIsoDate)(cursor) <= last; cursor.setUTCDate(cursor.getUTCDate() + 1)) {
+        dates.push((0, exports.toIsoDate)(cursor));
+    }
+    return dates;
+};
+exports.eachDate = eachDate;
+/** Monday to Friday and not one of the organization's holidays. */
+const isWorkingDay = (isoDate, holidays) => !WEEKEND_DAYS.has(parseIsoDate(isoDate).getUTCDay()) && !holidays.has(isoDate.slice(0, 10));
+exports.isWorkingDay = isWorkingDay;
+/**
+ * The days a request is worth: the working days from `start` to `end` inclusive, halved for a
+ * half day. A half day is only meaningful on a single working day, so it yields 0.5 there and 0
+ * on a weekend or holiday - the caller rejects a zero either way.
+ */
+const countWorkingDays = (start, end, holidays, isHalfDay = false) => {
+    const working = (0, exports.eachDate)(start, end).filter((date) => (0, exports.isWorkingDay)(date, holidays)).length;
+    return isHalfDay ? working * 0.5 : working;
+};
+exports.countWorkingDays = countWorkingDays;
+/** The day before the same date next year - the end of a period that starts on `isoDate`. */
+const addOneYearMinusDay = (isoDate) => {
+    const date = parseIsoDate(isoDate);
+    date.setUTCFullYear(date.getUTCFullYear() + 1);
+    date.setUTCDate(date.getUTCDate() - 1);
+    return (0, exports.toIsoDate)(date);
+};
+exports.addOneYearMinusDay = addOneYearMinusDay;
+/**
+ * The leave year containing `date` for an organization whose year starts on the first of
+ * `startMonth` (1-12, `organizations.leave_calendar_start_month`). A March start puts
+ * 2026-02-10 in the year that began 2025-03-01.
+ */
+const leavePeriodFor = (date, startMonth) => {
+    const parsed = parseIsoDate(date);
+    const year = parsed.getUTCMonth() + 1 >= startMonth ? parsed.getUTCFullYear() : parsed.getUTCFullYear() - 1;
+    const period_start = (0, exports.toIsoDate)(new Date(Date.UTC(year, startMonth - 1, 1)));
+    return { period_start, period_end: (0, exports.addOneYearMinusDay)(period_start) };
+};
+exports.leavePeriodFor = leavePeriodFor;
+const isWithinPeriod = (date, period) => {
+    const day = date.slice(0, 10);
+    return day >= period.period_start && day <= period.period_end;
+};
+exports.isWithinPeriod = isWithinPeriod;

package/dist/permissions/dto.d.ts

@@ -12,6 +12,18 @@ export declare class UpdatePermissionsDto implements UpdatePermissionsDtoType {
     readonly read_tasks: boolean;
     readonly update_tasks: boolean;
     readonly delete_tasks: boolean;
+    readonly create_leave: boolean;
+    readonly read_leave: boolean;
+    readonly update_leave: boolean;
+    readonly delete_leave: boolean;
+    readonly create_leave_types: boolean;
+    readonly read_leave_types: boolean;
+    readonly update_leave_types: boolean;
+    readonly delete_leave_types: boolean;
+    readonly create_leave_requests: boolean;
+    readonly read_leave_requests: boolean;
+    readonly update_leave_requests: boolean;
+    readonly delete_leave_requests: boolean;
     readonly read_invoices: boolean;
     readonly create_users: boolean;
     readonly read_users: boolean;

package/dist/permissions/dto.js

@@ -42,30 +42,18 @@ class UpdatePermissionsDto {
     // readonly update_documents!: boolean;
     // @IsBoolean({ message: 'Delete Documents must be a boolean' })
     // readonly delete_documents!: boolean;
-    // @IsBoolean({ message: 'Create Leave must be a boolean' })
-    // readonly create_leave!: boolean;
-    // @IsBoolean({ message: 'Read Leave must be a boolean' })
-    // readonly read_leave!: boolean;
-    // @IsBoolean({ message: 'Update Leave must be a boolean' })
-    // readonly update_leave!: boolean;
-    // @IsBoolean({ message: 'Delete Leave must be a boolean' })
-    // readonly delete_leave!: boolean;
-    // @IsBoolean({ message: 'Create Leave Types must be a boolean' })
-    // readonly create_leave_types!: boolean;
-    // @IsBoolean({ message: 'Read Leave Types must be a boolean' })
-    // readonly read_leave_types!: boolean;
-    // @IsBoolean({ message: 'Update Leave Types must be a boolean' })
-    // readonly update_leave_types!: boolean;
-    // @IsBoolean({ message: 'Delete Leave Types must be a boolean' })
-    // readonly delete_leave_types!: boolean;
-    // @IsBoolean({ message: 'Create Leave Requests must be a boolean' })
-    // readonly create_leave_requests!: boolean;
-    // @IsBoolean({ message: 'Read Leave Requests must be a boolean' })
-    // readonly read_leave_requests!: boolean;
-    // @IsBoolean({ message: 'Update Leave Requests must be a boolean' })
-    // readonly update_leave_requests!: boolean;
-    // @IsBoolean({ message: 'Delete Leave Requests must be a boolean' })
-    // readonly delete_leave_requests!: boolean;
+    create_leave;
+    read_leave;
+    update_leave;
+    delete_leave;
+    create_leave_types;
+    read_leave_types;
+    update_leave_types;
+    delete_leave_types;
+    create_leave_requests;
+    read_leave_requests;
+    update_leave_requests;
+    delete_leave_requests;
     // @IsBoolean({ message: 'Create Invoices must be a boolean' })
     // readonly create_invoices!: boolean;
     read_invoices;
@@ -164,6 +152,54 @@ __decorate([
     (0, class_validator_1.IsBoolean)({ message: 'Delete Tasks must be a boolean' }),
     __metadata("design:type", Boolean)
 ], UpdatePermissionsDto.prototype, "delete_tasks", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Create Leave must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "create_leave", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Read Leave must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "read_leave", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Update Leave must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "update_leave", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Delete Leave must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "delete_leave", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Create Leave Types must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "create_leave_types", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Read Leave Types must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "read_leave_types", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Update Leave Types must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "update_leave_types", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Delete Leave Types must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "delete_leave_types", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Create Leave Requests must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "create_leave_requests", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Read Leave Requests must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "read_leave_requests", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Update Leave Requests must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "update_leave_requests", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Delete Leave Requests must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "delete_leave_requests", void 0);
 __decorate([
     (0, class_validator_1.IsBoolean)({ message: 'Read Invoices must be a boolean' }),
     __metadata("design:type", Boolean)

package/dist/public-holidays/dto.d.ts

@@ -0,0 +1,4 @@
+import type { GetPublicHolidaysDto as GetPublicHolidaysDtoType } from '@managemint-solutions/entities/public-holidays/dto';
+export declare class GetPublicHolidaysDto implements GetPublicHolidaysDtoType {
+    readonly year?: number | null;
+}

package/dist/public-holidays/dto.js

@@ -0,0 +1,30 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPublicHolidaysDto = void 0;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const validators_1 = require("../validators");
+// class-validator version of the shared DTO type from @managemint-solutions/entities.
+// The class `implements` its entities type so the wire contract cannot drift.
+class GetPublicHolidaysDto {
+    year;
+}
+exports.GetPublicHolidaysDto = GetPublicHolidaysDto;
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, validators_1.IsNullable)(),
+    (0, class_transformer_1.Transform)(({ value }) => (value ? Number(value) : value), { toClassOnly: true }),
+    (0, class_validator_1.IsInt)({ message: 'Year must be a whole number' }),
+    (0, class_validator_1.Min)(2000, { message: 'Year must be 2000 or later' }),
+    (0, class_validator_1.Max)(2100, { message: 'Year must be 2100 or earlier' }),
+    __metadata("design:type", Object)
+], GetPublicHolidaysDto.prototype, "year", void 0);

package/dist/public-holidays/index.d.ts

@@ -0,0 +1,21 @@
+import type { PublicHolidayEntity } from '@managemint-solutions/entities/public-holidays';
+import type { TypedSupabaseClient } from '../client';
+import type { GetPublicHolidaysDto } from './dto';
+export * from './dto';
+/**
+ * The public-holiday calendar. Global, like configs: every signed-in caller reads the same
+ * rows (the READ policy is `true` - there is no tenant on them), so this hangs off the user
+ * client with no auth context, and nothing writes them but Scott in Supabase Studio.
+ */
+export declare class PublicHolidaysResource {
+    private readonly supabase;
+    constructor(supabase: TypedSupabaseClient);
+    /** The calendar in date order, or one calendar year of it. */
+    list(query: GetPublicHolidaysDto): Promise<PublicHolidayEntity[]>;
+    /**
+     * The dates between `start` and `end` (inclusive) that are a day off for everyone - the input
+     * to leave's working-day count. A faith-specific holiday (`religion` set) is on the calendar
+     * but does not shorten a request, since nothing yet says which employees observe it.
+     */
+    datesBetween(start: string, end: string): Promise<Set<string>>;
+}