@house-rules/party 0.0.0-stage → 0.1.0

package/dist/person/principal.js

@@ -0,0 +1,49 @@
+import { ActorId, errorKind } from "@house-rules/domain/contract";
+import { Schema } from "effect";
+import { Person } from "./person.js";
+export const PrincipalKind = Schema.Literals(["person", "agent"]);
+export const PrincipalHandle = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(120));
+export const Principal = Schema.Struct({
+    ...Person.fields,
+    kind: PrincipalKind,
+    handle: Schema.String,
+    createdBy: Schema.NullOr(ActorId),
+    disabledAt: Schema.NullOr(Schema.Int),
+});
+export const CreatePrincipal = Schema.Struct({
+    id: Schema.optionalKey(ActorId),
+    displayName: Schema.String,
+    kind: PrincipalKind,
+    handle: Schema.String,
+    createdBy: Schema.NullOr(ActorId),
+});
+export const PrincipalCreated = Schema.Struct({
+    kind: Schema.Literal("principal.created"),
+    after: Principal,
+});
+export const PrincipalDisabled = Schema.Struct({
+    kind: Schema.Literal("principal.disabled"),
+    before: Principal,
+    after: Principal,
+});
+export const CreatedPrincipal = Schema.Struct({ principal: Principal, fact: PrincipalCreated });
+export const DisabledPrincipal = Schema.Struct({
+    principal: Principal,
+    fact: Schema.NullOr(PrincipalDisabled),
+});
+export class PrincipalDisabledRefused extends Schema.TaggedError()("PrincipalDisabledRefused", { kind: errorKind("forbidden") }) {
+}
+export class PrincipalKindRefused extends Schema.TaggedError()("PrincipalKindRefused", { kind: errorKind("forbidden") }) {
+}
+export const legacyPrincipal = (person) => ({
+    ...person,
+    kind: "person",
+    handle: person.id,
+    createdBy: null,
+    disabledAt: null,
+});
+export const personOf = ({ id, displayName, createdAt }) => ({
+    id,
+    displayName,
+    createdAt,
+});

package/dist/person/principals.d.ts

@@ -0,0 +1,102 @@
+import { ActorId, type NoOpenUnit } from "@house-rules/domain";
+import { Effect } from "effect";
+import type { PartyOptions } from "../role/role.js";
+import type { PersonStore } from "../storage.js";
+import { PersonAlreadyExists, PersonInputInvalid, PersonNotFound, type PersonStoreUnavailable } from "./person.js";
+import { PrincipalDisabledRefused, PrincipalKindRefused, type PrincipalKind } from "./principal.js";
+export declare const makePrincipals: (store: PersonStore["Service"], options: PartyOptions) => {
+    createPrincipal: (input: {
+        readonly id?: string & import("effect/Brand").Brand<"ActorId">;
+        readonly displayName: string;
+        readonly kind: "agent" | "person";
+        readonly handle: string;
+        readonly createdBy: (string & import("effect/Brand").Brand<"ActorId">) | null;
+    }) => Effect.Effect<{
+        readonly principal: {
+            readonly id: string & import("effect/Brand").Brand<"ActorId">;
+            readonly displayName: string;
+            readonly createdAt: number;
+            readonly kind: "agent" | "person";
+            readonly handle: string;
+            readonly createdBy: (string & import("effect/Brand").Brand<"ActorId">) | null;
+            readonly disabledAt: number | null;
+        };
+        readonly fact: {
+            readonly kind: "principal.created";
+            readonly after: {
+                readonly id: string & import("effect/Brand").Brand<"ActorId">;
+                readonly displayName: string;
+                readonly createdAt: number;
+                readonly kind: "agent" | "person";
+                readonly handle: string;
+                readonly createdBy: (string & import("effect/Brand").Brand<"ActorId">) | null;
+                readonly disabledAt: number | null;
+            };
+        };
+    }, NoOpenUnit | PersonAlreadyExists | PersonInputInvalid | PersonStoreUnavailable, never>;
+    standingOf: (id: string & import("effect/Brand").Brand<"ActorId">) => Effect.Effect<"active" | "disabled" | "missing", PersonStoreUnavailable, never>;
+    lockActive: (input: {
+        readonly handle: string;
+        readonly kind: PrincipalKind;
+    }) => Effect.Effect<{
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+        readonly displayName: string;
+        readonly createdAt: number;
+        readonly kind: "agent" | "person";
+        readonly handle: string;
+        readonly createdBy: (string & import("effect/Brand").Brand<"ActorId">) | null;
+        readonly disabledAt: number | null;
+    }, NoOpenUnit | PersonNotFound | PersonStoreUnavailable | PrincipalDisabledRefused | PrincipalKindRefused, never>;
+    disable: (id: string & import("effect/Brand").Brand<"ActorId">) => Effect.Effect<{
+        readonly principal: {
+            readonly id: string & import("effect/Brand").Brand<"ActorId">;
+            readonly displayName: string;
+            readonly createdAt: number;
+            readonly kind: "agent" | "person";
+            readonly handle: string;
+            readonly createdBy: (string & import("effect/Brand").Brand<"ActorId">) | null;
+            readonly disabledAt: number | null;
+        };
+        readonly fact: {
+            readonly kind: "principal.disabled";
+            readonly before: {
+                readonly id: string & import("effect/Brand").Brand<"ActorId">;
+                readonly displayName: string;
+                readonly createdAt: number;
+                readonly kind: "agent" | "person";
+                readonly handle: string;
+                readonly createdBy: (string & import("effect/Brand").Brand<"ActorId">) | null;
+                readonly disabledAt: number | null;
+            };
+            readonly after: {
+                readonly id: string & import("effect/Brand").Brand<"ActorId">;
+                readonly displayName: string;
+                readonly createdAt: number;
+                readonly kind: "agent" | "person";
+                readonly handle: string;
+                readonly createdBy: (string & import("effect/Brand").Brand<"ActorId">) | null;
+                readonly disabledAt: number | null;
+            };
+        } | null;
+    }, NoOpenUnit | PersonNotFound | PersonStoreUnavailable, never>;
+    findPrincipal: (input: {
+        readonly handle: string;
+    }) => Effect.Effect<{
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+        readonly displayName: string;
+        readonly createdAt: number;
+        readonly kind: "agent" | "person";
+        readonly handle: string;
+        readonly createdBy: (string & import("effect/Brand").Brand<"ActorId">) | null;
+        readonly disabledAt: number | null;
+    }, PersonNotFound | PersonStoreUnavailable, never>;
+    principalsByIds: (ids: readonly ActorId[]) => Effect.Effect<readonly {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+        readonly displayName: string;
+        readonly createdAt: number;
+        readonly kind: "agent" | "person";
+        readonly handle: string;
+        readonly createdBy: (string & import("effect/Brand").Brand<"ActorId">) | null;
+        readonly disabledAt: number | null;
+    }[], PersonStoreUnavailable, never>;
+};

package/dist/person/principals.js

@@ -0,0 +1,73 @@
+import { ActorId, UnitOfWork } from "@house-rules/domain";
+import { DateTime, Effect, Random, Schema } from "effect";
+import { DisplayName, PersonAlreadyExists, PersonInputInvalid, PersonNotFound, } from "./person.js";
+import { CreatePrincipal, PrincipalDisabledRefused, PrincipalHandle, PrincipalKindRefused, } from "./principal.js";
+export const makePrincipals = (store, options) => {
+    const handle = options.handles?.pattern
+        ? PrincipalHandle.check(Schema.isPattern(options.handles.pattern))
+        : PrincipalHandle;
+    const decodeInput = Schema.decodeUnknownEffect(CreatePrincipal);
+    const decodeHandle = Schema.decodeUnknownEffect(handle);
+    const decodeName = Schema.decodeUnknownEffect(DisplayName);
+    const invalid = () => new PersonInputInvalid({ message: "Invalid principal input." });
+    return {
+        createPrincipal: Effect.fn("Party.createPrincipal")(function* (input) {
+            yield* UnitOfWork.required;
+            const decoded = yield* decodeInput(input).pipe(Effect.mapError(invalid));
+            const handle = yield* decodeHandle(decoded.handle).pipe(Effect.mapError(invalid));
+            if (options.handles?.reserved?.includes(handle))
+                return yield* invalid();
+            const displayName = yield* decodeName(decoded.displayName).pipe(Effect.mapError(invalid));
+            const words = yield* Effect.all(Array.from({ length: 4 }, () => Random.nextIntBetween(0, 0xffff_ffff)));
+            const principal = {
+                ...decoded,
+                id: decoded.id ?? ActorId.make(words.map((w) => w.toString(16).padStart(8, "0")).join("")),
+                handle,
+                displayName,
+                createdAt: DateTime.toEpochMillis(yield* DateTime.now),
+                disabledAt: null,
+            };
+            if (!(yield* store.insertPrincipal(principal)))
+                return yield* new PersonAlreadyExists();
+            return { principal, fact: { kind: "principal.created", after: principal } };
+        }),
+        standingOf: Effect.fn("Party.standingOf")(function* (id) {
+            const principal = yield* store.principal(id);
+            return principal === undefined
+                ? "missing"
+                : principal.disabledAt === null
+                    ? "active"
+                    : "disabled";
+        }),
+        lockActive: Effect.fn("Party.lockActive")(function* (input) {
+            yield* UnitOfWork.required;
+            const principal = yield* store.lockPrincipal(input.handle);
+            if (!principal)
+                return yield* new PersonNotFound();
+            if (principal.kind !== input.kind)
+                return yield* new PrincipalKindRefused();
+            if (principal.disabledAt !== null)
+                return yield* new PrincipalDisabledRefused();
+            return principal;
+        }),
+        disable: Effect.fn("Party.disable")(function* (id) {
+            yield* UnitOfWork.required;
+            const before = yield* store.principalForUpdate(id);
+            if (!before)
+                return yield* new PersonNotFound();
+            if (before.disabledAt !== null)
+                return { principal: before, fact: null };
+            const after = yield* store.disable(id, DateTime.toEpochMillis(yield* DateTime.now));
+            if (!after)
+                return yield* new PersonNotFound();
+            return { principal: after, fact: { kind: "principal.disabled", before, after } };
+        }),
+        findPrincipal: Effect.fn("Party.findPrincipal")(function* (input) {
+            const principal = yield* store.principalByHandle(input.handle);
+            if (!principal)
+                return yield* new PersonNotFound();
+            return principal;
+        }),
+        principalsByIds: (ids) => store.principalsByIds(ids),
+    };
+};

package/dist/relationship/relationship.d.ts

@@ -0,0 +1,30 @@
+import { Effect, Schema } from "effect";
+import { PartyInputInvalid } from "../organisation/organisation.js";
+export declare const PartyReference: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["person", "organisation"]>;
+    readonly id: Schema.NonEmptyString;
+}>;
+export type PartyReference = typeof PartyReference.Type;
+export declare const Relationship: Schema.Struct<{
+    readonly from: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["person", "organisation"]>;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly to: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["person", "organisation"]>;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly kind: Schema.NonEmptyString;
+}>;
+export type Relationship = typeof Relationship.Type;
+export declare const validateRelationship: (input: Relationship) => Effect.Effect<{
+    readonly from: {
+        readonly kind: "organisation" | "person";
+        readonly id: string;
+    };
+    readonly to: {
+        readonly kind: "organisation" | "person";
+        readonly id: string;
+    };
+    readonly kind: string;
+}, PartyInputInvalid, never>;

package/dist/relationship/relationship.js

@@ -0,0 +1,12 @@
+import { Effect, Schema } from "effect";
+import { PartyInputInvalid } from "../organisation/organisation.js";
+export const PartyReference = Schema.Struct({
+    kind: Schema.Literals(["person", "organisation"]),
+    id: Schema.NonEmptyString,
+});
+export const Relationship = Schema.Struct({
+    from: PartyReference,
+    to: PartyReference,
+    kind: Schema.NonEmptyString,
+});
+export const validateRelationship = (input) => Schema.decodeEffect(Relationship)(input).pipe(Effect.mapError(() => new PartyInputInvalid({ message: "Invalid relationship." })));

package/dist/relationship/removal.d.ts

@@ -0,0 +1,101 @@
+import { Effect } from "effect";
+import { PartyLastAdmin, type PartyUnavailable } from "../organisation/organisation.js";
+import type { Relationship } from "./relationship.js";
+export declare const removeStaffAssignments: (store: {
+    readonly organisation: (id: string) => Effect.Effect<{
+        readonly id: string;
+        readonly name: string;
+    } | undefined, PartyUnavailable, never>;
+    readonly organisationsFor: (personId: import("@house-rules/domain").ActorId) => Effect.Effect<readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly relation: string | null;
+    }[], PartyUnavailable, never>;
+    readonly relationsFor: (personId: import("@house-rules/domain").ActorId, organisationIds: readonly string[] | null) => Effect.Effect<readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly relation: string;
+    }[], PartyUnavailable, never>;
+    readonly scopedAssignments: (personId: import("@house-rules/domain").ActorId, organisationIds: readonly string[] | null) => Effect.Effect<readonly {
+        readonly personId: string & import("effect/Brand").Brand<"ActorId">;
+        readonly roleKey: string;
+        readonly organisationId: string | null;
+    }[], PartyUnavailable, never>;
+    readonly assignmentsInOrganisation: (organisationId: string) => Effect.Effect<readonly {
+        readonly personId: string & import("effect/Brand").Brand<"ActorId">;
+        readonly roleKey: string;
+        readonly organisationId: string | null;
+    }[], PartyUnavailable, never>;
+    readonly holderIds: (role: string, scope: string | null, take: number) => Effect.Effect<readonly (string & import("effect/Brand").Brand<"ActorId">)[], PartyUnavailable, never>;
+    readonly lockOrganisation: (organisationId: string) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | PartyUnavailable, never>;
+    readonly memberIds: (organisationIds: readonly string[]) => Effect.Effect<readonly (string & import("effect/Brand").Brand<"ActorId">)[], PartyUnavailable, never>;
+    readonly insertInvitation: (value: import("../invitation/invitation.ts").StoredInvitation) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | PartyUnavailable, never>;
+    readonly consumeInvitation: (hash: string, now: number) => Effect.Effect<{
+        readonly id: string;
+        readonly organisationId: string;
+        readonly roleKey: string | null;
+        readonly createdBy: string & import("effect/Brand").Brand<"ActorId">;
+        readonly expiresAt: number;
+        readonly state: "pending" | "revoked" | "used";
+        readonly codeHash: string;
+    } | undefined, import("@house-rules/domain").NoOpenUnit | PartyUnavailable, never>;
+    readonly invitation: (id: string) => Effect.Effect<{
+        readonly id: string;
+        readonly organisationId: string;
+        readonly roleKey: string | null;
+        readonly createdBy: string & import("effect/Brand").Brand<"ActorId">;
+        readonly expiresAt: number;
+        readonly state: "pending" | "revoked" | "used";
+        readonly codeHash: string;
+    } | undefined, PartyUnavailable, never>;
+    readonly invitations: (organisationId: string) => Effect.Effect<readonly {
+        readonly id: string;
+        readonly organisationId: string;
+        readonly roleKey: string | null;
+        readonly createdBy: string & import("effect/Brand").Brand<"ActorId">;
+        readonly expiresAt: number;
+        readonly state: "pending" | "revoked" | "used";
+        readonly codeHash: string;
+    }[], PartyUnavailable, never>;
+    readonly revokeInvitation: (id: string) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | PartyUnavailable, never>;
+    readonly insertOrganisation: (organisation: import("../organisation/organisation.js").Organisation) => Effect.Effect<boolean, import("@house-rules/domain").NoOpenUnit | PartyUnavailable, never>;
+    readonly relate: (relationship: Relationship) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | PartyUnavailable, never>;
+    readonly unrelate: (relationship: Relationship) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | PartyUnavailable, never>;
+    readonly isRelated: (relationship: Relationship) => Effect.Effect<boolean, PartyUnavailable, never>;
+    readonly role: (key: string) => Effect.Effect<{
+        readonly key: string;
+        readonly name: string;
+        readonly permissions: readonly string[];
+        readonly organisationId: string | null;
+        readonly builtIn: boolean;
+    } | undefined, PartyUnavailable, never>;
+    readonly roles: (organisationIds?: readonly string[] | null) => Effect.Effect<readonly {
+        readonly key: string;
+        readonly name: string;
+        readonly permissions: readonly string[];
+        readonly organisationId: string | null;
+        readonly builtIn: boolean;
+    }[], PartyUnavailable, never>;
+    readonly putRole: (role: import("../contract.ts").Role) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | PartyUnavailable, never>;
+    readonly deleteRole: (key: string) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | PartyUnavailable, never>;
+    readonly assign: (assignment: import("../contract.ts").Assignment) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | PartyUnavailable, never>;
+    readonly revoke: (assignment: import("../contract.ts").Assignment) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | PartyUnavailable, never>;
+    readonly assignments: (personId: import("@house-rules/domain").ActorId, organisationIds?: readonly string[] | null, builtInKeys?: readonly string[]) => Effect.Effect<readonly {
+        readonly personId: string & import("effect/Brand").Brand<"ActorId">;
+        readonly roleKey: string;
+        readonly organisationId: string | null;
+    }[], PartyUnavailable, never>;
+}, role: (key: string) => Effect.Effect<{
+    readonly organisationId: string | null;
+    readonly permissions: readonly string[];
+} | undefined, PartyUnavailable>, value: {
+    readonly from: {
+        readonly kind: "organisation" | "person";
+        readonly id: string;
+    };
+    readonly to: {
+        readonly kind: "organisation" | "person";
+        readonly id: string;
+    };
+    readonly kind: string;
+}) => Effect.Effect<undefined, import("@house-rules/domain").NoOpenUnit | PartyLastAdmin | PartyUnavailable, never>;

package/dist/relationship/removal.js

@@ -0,0 +1,22 @@
+import { Effect } from "effect";
+import { PartyLastAdmin } from "../organisation/organisation.js";
+export const removeStaffAssignments = Effect.fn("Party.removeStaffAssignments")(function* (store, role, value) {
+    if (value.from.kind !== "person" || value.to.kind !== "organisation" || value.kind !== "staff")
+        return;
+    // Serialize removals so two admins cannot each see the other one and both leave.
+    yield* store.lockOrganisation(value.to.id);
+    const assignments = yield* store.assignmentsInOrganisation(value.to.id);
+    const admins = new Set();
+    for (const assignment of assignments) {
+        const held = yield* role(assignment.roleKey);
+        if (held &&
+            (held.organisationId === null || held.organisationId === value.to.id) &&
+            held.permissions.includes("party:admin"))
+            admins.add(assignment.personId);
+    }
+    if (admins.has(value.from.id) && admins.size === 1)
+        return yield* new PartyLastAdmin();
+    for (const assignment of assignments)
+        if (assignment.personId === value.from.id)
+            yield* store.revoke(assignment);
+});

package/dist/role/access.d.ts

@@ -0,0 +1,171 @@
+import { type Caller, type ActorId } from "@house-rules/domain";
+import { Effect } from "effect";
+import { PartyConflict, PartyDenied, PartyInputInvalid, PartyNotFound, PartyUnavailable } from "../organisation/organisation.js";
+import { type Relationship } from "../relationship/relationship.js";
+import type { PartyStore, PersonStore } from "../storage.js";
+import type { RoleCatalogue } from "./permission-catalogue.js";
+import { type PartyOptions } from "./role.js";
+export declare const makeAccess: (store: PartyStore["Service"], persons: {
+    readonly find: (id: ActorId) => Effect.Effect<unknown, PartyUnavailable>;
+    readonly principal: (id: ActorId) => Effect.Effect<{
+        readonly disabledAt: number | null;
+    } | undefined, PartyUnavailable>;
+    readonly list: (ids: readonly ActorId[] | null) => Effect.Effect<Effect.Success<ReturnType<PersonStore["Service"]["list"]>>, PartyUnavailable>;
+}, options: PartyOptions, catalogue: RoleCatalogue | undefined) => {
+    listPeople: (caller: Caller) => Effect.Effect<{
+        id: string & import("effect/Brand").Brand<"ActorId">;
+        displayName: string;
+        createdAt: number;
+        assignments: {
+            roleKey: string;
+            roleName: string;
+            organisationId: string | null;
+            organisationName: string | null;
+        }[];
+        organisations: readonly {
+            readonly id: string;
+            readonly name: string;
+            readonly relation: string;
+        }[];
+    }[], PartyDenied | PartyUnavailable, never>;
+    listMembers: (caller: Caller, organisationId: string) => Effect.Effect<{
+        id: string & import("effect/Brand").Brand<"ActorId">;
+        displayName: string;
+        createdAt: number;
+        relation: string | null;
+        roles: {
+            roleKey: string;
+            roleName: string;
+        }[];
+    }[], PartyNotFound | PartyUnavailable, never>;
+    myOrganisations: (caller: Caller) => Effect.Effect<{
+        id: string;
+        name: string;
+        relation: string | null;
+        roles: {
+            roleKey: string;
+            roleName: string;
+            permissions: readonly string[];
+        }[];
+    }[], PartyDenied | PartyUnavailable, never>;
+    holdersOf: (input: {
+        readonly role: string;
+        readonly scope?: string | null;
+    }) => Effect.Effect<{
+        ids: (string & import("effect/Brand").Brand<"ActorId">)[];
+        truncated: boolean;
+    }, PartyUnavailable, never>;
+    createInvitation: (caller: Caller, input: {
+        readonly organisationId: string;
+        readonly roleKey: string | null;
+    }) => Effect.Effect<{
+        invitation: {
+            id: string;
+            organisationId: string;
+            roleKey: string | null;
+            createdBy: string & import("effect/Brand").Brand<"ActorId">;
+            expiresAt: number;
+            state: "pending" | "revoked" | "used";
+        };
+        code: string;
+    }, import("@house-rules/domain").NoOpenUnit | PartyDenied | PartyNotFound | PartyUnavailable, never>;
+    acceptInvitation: (caller: Caller, code: string) => Effect.Effect<{
+        organisationId: string;
+        roleKey: string | null;
+        personId: string & import("effect/Brand").Brand<"ActorId">;
+    }, import("@house-rules/domain").NoOpenUnit | PartyDenied | PartyNotFound | PartyUnavailable, never>;
+    revokeInvitation: (caller: Caller, id: string) => Effect.Effect<undefined, import("@house-rules/domain").NoOpenUnit | PartyDenied | PartyNotFound | PartyUnavailable, never>;
+    listInvitations: (caller: Caller, organisationId: string) => Effect.Effect<{
+        id: string;
+        organisationId: string;
+        roleKey: string | null;
+        createdBy: string & import("effect/Brand").Brand<"ActorId">;
+        expiresAt: number;
+        state: "pending" | "revoked" | "used";
+    }[], PartyDenied | PartyUnavailable, never>;
+    permissionsOf: (caller: Readonly<{
+        kind: "person";
+        actor: import("@house-rules/domain").Actor;
+        via: string;
+    }>) => Effect.Effect<`${string}:${string}`[], PartyUnavailable, never>;
+    canAdminOrganisation: (caller: Caller, organisationId: string) => Effect.Effect<boolean, PartyUnavailable, never>;
+    myAccess: (caller: Caller) => Effect.Effect<{
+        roles: readonly {
+            readonly personId: string & import("effect/Brand").Brand<"ActorId">;
+            readonly roleKey: string;
+            readonly organisationId: string | null;
+        }[];
+        permissions: `${string}:${string}`[];
+        catalogue: `${string}:${string}`[];
+    }, PartyDenied | PartyUnavailable, never>;
+    createOrganisation: (caller: Caller, input: {
+        readonly id: string;
+        readonly name: string;
+    }) => Effect.Effect<{
+        readonly id: string;
+        readonly name: string;
+    }, import("@house-rules/domain").NoOpenUnit | PartyConflict | PartyDenied | PartyInputInvalid | PartyUnavailable, never>;
+    showOrganisation: (id: string) => Effect.Effect<{
+        readonly id: string;
+        readonly name: string;
+    }, PartyNotFound | PartyUnavailable, never>;
+    relate: (caller: Caller, input: {
+        readonly from: {
+            readonly kind: "organisation" | "person";
+            readonly id: string;
+        };
+        readonly to: {
+            readonly kind: "organisation" | "person";
+            readonly id: string;
+        };
+        readonly kind: string;
+    }) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | PartyDenied | PartyInputInvalid | PartyNotFound | PartyUnavailable, never>;
+    unrelate: (caller: Caller, input: {
+        readonly from: {
+            readonly kind: "organisation" | "person";
+            readonly id: string;
+        };
+        readonly to: {
+            readonly kind: "organisation" | "person";
+            readonly id: string;
+        };
+        readonly kind: string;
+    }) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | PartyDenied | PartyInputInvalid | import("../organisation/organisation.js").PartyLastAdmin | PartyUnavailable, never>;
+    isRelated: (input: Relationship) => Effect.Effect<boolean, PartyInputInvalid | PartyUnavailable, never>;
+    defineRole: (caller: Caller, input: Omit<{
+        readonly key: string;
+        readonly name: string;
+        readonly permissions: readonly string[];
+        readonly organisationId: string | null;
+        readonly builtIn: boolean;
+    }, "builtIn">) => Effect.Effect<{
+        readonly key: string;
+        readonly name: string;
+        readonly permissions: readonly string[];
+        readonly organisationId: string | null;
+        readonly builtIn: boolean;
+    }, import("@house-rules/domain").NoOpenUnit | PartyConflict | PartyDenied | PartyInputInvalid | PartyNotFound | PartyUnavailable, never>;
+    deleteRole: (caller: Caller, key: string) => Effect.Effect<undefined, import("@house-rules/domain").NoOpenUnit | PartyConflict | PartyDenied | PartyNotFound | PartyUnavailable, never>;
+    listRoles: (caller: Caller) => Effect.Effect<{
+        readonly key: string;
+        readonly name: string;
+        readonly permissions: readonly string[];
+        readonly organisationId: string | null;
+        readonly builtIn: boolean;
+    }[], PartyUnavailable, never>;
+    assignRole: (caller: Caller, input: {
+        readonly personId: string & import("effect/Brand").Brand<"ActorId">;
+        readonly roleKey: string;
+        readonly organisationId: string | null;
+    }) => Effect.Effect<undefined, import("@house-rules/domain").NoOpenUnit | PartyDenied | PartyInputInvalid | PartyNotFound | PartyUnavailable, never>;
+    revokeRole: (caller: Caller, input: {
+        readonly personId: string & import("effect/Brand").Brand<"ActorId">;
+        readonly roleKey: string;
+        readonly organisationId: string | null;
+    }) => Effect.Effect<void, import("@house-rules/domain").NoOpenUnit | PartyDenied | PartyInputInvalid | PartyUnavailable, never>;
+    rolesOf: (caller: Caller, personId: string & import("effect/Brand").Brand<"ActorId">) => Effect.Effect<readonly {
+        readonly personId: string & import("effect/Brand").Brand<"ActorId">;
+        readonly roleKey: string;
+        readonly organisationId: string | null;
+    }[], PartyUnavailable, never>;
+};