@house-rules/party 0.0.0-stage → 0.1.0

package/dist/invitation/invitations.d.ts

@@ -0,0 +1,34 @@
+import { type Caller } from "@house-rules/domain";
+import { Effect } from "effect";
+import { PartyDenied, PartyNotFound, PartyUnavailable } from "../organisation/organisation.js";
+import type { PartyStore } from "../storage.js";
+export declare const makeInvitations: (store: PartyStore["Service"], admin: (caller: Caller, organisationId: string | null) => Effect.Effect<void, PartyDenied | PartyUnavailable>, checkRole: (caller: Caller, key: string, org: string) => Effect.Effect<void, PartyDenied | PartyNotFound | PartyUnavailable>) => {
+    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>;
+};

package/dist/invitation/invitations.js

@@ -0,0 +1,70 @@
+import { UnitOfWork } from "@house-rules/domain";
+import { Clock, Effect } from "effect";
+import { Hex } from "effect/encoding";
+import { PartyDenied, PartyNotFound, PartyUnavailable } from "../organisation/organisation.js";
+const publicInvitation = ({ codeHash: _hash, ...value }) => value;
+const hashCode = (code) => Effect.tryPromise({
+    try: () => globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(code)),
+    catch: (cause) => new PartyUnavailable({ cause }),
+}).pipe(Effect.map((bytes) => Hex.encode(new Uint8Array(bytes))));
+const randomCode = Effect.sync(() => Hex.encode(globalThis.crypto.getRandomValues(new Uint8Array(32))));
+export const makeInvitations = (store, admin, checkRole) => ({
+    createInvitation: Effect.fn("Party.createInvitation")(function* (caller, input) {
+        yield* UnitOfWork.required;
+        yield* admin(caller, input.organisationId);
+        if (caller.kind !== "person")
+            return yield* new PartyDenied();
+        if (!(yield* store.organisation(input.organisationId)))
+            return yield* new PartyNotFound();
+        if (input.roleKey !== null)
+            yield* checkRole(caller, input.roleKey, input.organisationId);
+        const code = yield* randomCode;
+        const value = {
+            id: yield* randomCode,
+            organisationId: input.organisationId,
+            roleKey: input.roleKey,
+            createdBy: caller.actor.id,
+            codeHash: yield* hashCode(code),
+            expiresAt: (yield* Clock.currentTimeMillis) + 7 * 24 * 60 * 60 * 1000,
+            state: "pending",
+        };
+        yield* store.insertInvitation(value);
+        return { invitation: publicInvitation(value), code };
+    }),
+    acceptInvitation: Effect.fn("Party.acceptInvitation")(function* (caller, code) {
+        yield* UnitOfWork.required;
+        if (caller.kind !== "person")
+            return yield* new PartyDenied();
+        const value = yield* store.consumeInvitation(yield* hashCode(code), yield* Clock.currentTimeMillis);
+        // One conditional UPDATE claims the code. A rolled-back feature restores it.
+        if (!value)
+            return yield* new PartyNotFound();
+        if (value.roleKey !== null)
+            yield* checkRole({ kind: "person", actor: { id: value.createdBy }, via: caller.via }, value.roleKey, value.organisationId).pipe(Effect.catchTags({
+                PartyDenied: () => new PartyNotFound(),
+                PartyNotFound: () => new PartyNotFound(),
+            }));
+        yield* store.relate({
+            from: { kind: "person", id: caller.actor.id },
+            to: { kind: "organisation", id: value.organisationId },
+            kind: "staff",
+        });
+        return {
+            organisationId: value.organisationId,
+            roleKey: value.roleKey,
+            personId: caller.actor.id,
+        };
+    }),
+    revokeInvitation: Effect.fn("Party.revokeInvitation")(function* (caller, id) {
+        yield* UnitOfWork.required;
+        const value = yield* store.invitation(id);
+        if (!value)
+            return yield* new PartyNotFound();
+        yield* admin(caller, value.organisationId);
+        yield* store.revokeInvitation(id);
+    }),
+    listInvitations: Effect.fn("Party.listInvitations")(function* (caller, organisationId) {
+        yield* admin(caller, organisationId);
+        return (yield* store.invitations(organisationId)).map(publicInvitation);
+    }),
+});

package/dist/organisation/organisation.d.ts

@@ -0,0 +1,59 @@
+import { Effect, Schema } from "effect";
+export declare const OrganisationId: Schema.NonEmptyString;
+export declare const Organisation: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly name: Schema.NonEmptyString;
+}>;
+export type Organisation = typeof Organisation.Type;
+export declare const OrganisationRelation: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly name: Schema.NonEmptyString;
+    readonly relation: Schema.String;
+}>;
+export type OrganisationRelation = typeof OrganisationRelation.Type;
+export declare const OwnOrganisation: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly name: Schema.NonEmptyString;
+    readonly relation: Schema.NullOr<Schema.String>;
+}>;
+export type OwnOrganisation = typeof OwnOrganisation.Type;
+declare const PartyNotFound_base: Schema.Class<PartyNotFound, Schema.TaggedStruct<"PartyNotFound", {
+    readonly kind: Schema.tag<"not_found">;
+}>, import("effect/Cause").YieldableError>;
+export declare class PartyNotFound extends PartyNotFound_base {
+}
+declare const PartyInputInvalid_base: Schema.Class<PartyInputInvalid, Schema.TaggedStruct<"PartyInputInvalid", {
+    readonly kind: Schema.tag<"invalid">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class PartyInputInvalid extends PartyInputInvalid_base {
+}
+declare const PartyDenied_base: Schema.Class<PartyDenied, Schema.TaggedStruct<"PartyDenied", {
+    readonly kind: Schema.tag<"forbidden">;
+}>, import("effect/Cause").YieldableError>;
+export declare class PartyDenied extends PartyDenied_base {
+    get message(): string;
+}
+declare const PartyLastAdmin_base: Schema.Class<PartyLastAdmin, Schema.TaggedStruct<"PartyLastAdmin", {
+    readonly kind: Schema.tag<"conflict">;
+    readonly message: Schema.tag<"An organisation must keep at least one administrator.">;
+}>, import("effect/Cause").YieldableError>;
+export declare class PartyLastAdmin extends PartyLastAdmin_base {
+}
+declare const PartyConflict_base: Schema.Class<PartyConflict, Schema.TaggedStruct<"PartyConflict", {
+    readonly kind: Schema.tag<"conflict">;
+}>, import("effect/Cause").YieldableError>;
+export declare class PartyConflict extends PartyConflict_base {
+}
+declare const PartyUnavailable_base: Schema.Class<PartyUnavailable, Schema.TaggedStruct<"PartyUnavailable", {
+    readonly kind: Schema.tag<"unavailable">;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class PartyUnavailable extends PartyUnavailable_base {
+    get message(): string;
+}
+export declare const validateOrganisation: (input: Organisation) => Effect.Effect<{
+    readonly id: string;
+    readonly name: string;
+}, PartyInputInvalid, never>;
+export {};

package/dist/organisation/organisation.js

@@ -0,0 +1,46 @@
+import { errorKind } from "@house-rules/domain/contract";
+import { Effect, Schema } from "effect";
+export const OrganisationId = Schema.NonEmptyString;
+export const Organisation = Schema.Struct({ id: OrganisationId, name: Schema.NonEmptyString });
+export const OrganisationRelation = Schema.Struct({
+    ...Organisation.fields,
+    relation: Schema.String,
+});
+export const OwnOrganisation = Schema.Struct({
+    ...Organisation.fields,
+    relation: Schema.NullOr(Schema.String),
+});
+export class PartyNotFound extends Schema.TaggedError()("PartyNotFound", {
+    kind: errorKind("not_found"),
+}) {
+}
+export class PartyInputInvalid extends Schema.TaggedError()("PartyInputInvalid", {
+    kind: errorKind("invalid"),
+    message: Schema.String,
+}) {
+}
+export class PartyDenied extends Schema.TaggedError()("PartyDenied", {
+    kind: errorKind("forbidden"),
+}) {
+    get message() {
+        return "You do not have permission for this action in this scope.";
+    }
+}
+export class PartyLastAdmin extends Schema.TaggedError()("PartyLastAdmin", {
+    kind: errorKind("conflict"),
+    message: Schema.tag("An organisation must keep at least one administrator."),
+}) {
+}
+export class PartyConflict extends Schema.TaggedError()("PartyConflict", {
+    kind: errorKind("conflict"),
+}) {
+}
+export class PartyUnavailable extends Schema.TaggedError()("PartyUnavailable", {
+    kind: errorKind("unavailable"),
+    cause: Schema.Defect(),
+}) {
+    get message() {
+        return "Party is unavailable. Try again shortly.";
+    }
+}
+export const validateOrganisation = (input) => Schema.decodeEffect(Organisation)(input).pipe(Effect.mapError(() => new PartyInputInvalid({ message: "Invalid organisation." })));

package/dist/person/bind-party.d.ts

@@ -0,0 +1,7 @@
+import { type Binding } from "@house-rules/application";
+import type { makeAccess } from "../role/access.js";
+import type { makeParty } from "./party.js";
+import type { makePrincipals } from "./principals.js";
+type Service = ReturnType<typeof makeParty> & ReturnType<typeof makeAccess> & ReturnType<typeof makePrincipals>;
+export declare const bindParty: (service: Service) => readonly Binding[];
+export {};

package/dist/person/bind-party.js

@@ -0,0 +1,42 @@
+import { bindOperation } from "@house-rules/application";
+import { Effect } from "effect";
+import { PartyOperations } from "./operations.js";
+import { PersonCallerDenied, PersonNotFound, PersonUpdateRefused } from "./person.js";
+export const bindParty = (service) => [
+    bindOperation(PartyOperations.createPrincipal, (input, { caller }) => caller.kind === "system"
+        ? service.createPrincipal(input)
+        : Effect.fail(new PersonCallerDenied())),
+    bindOperation(PartyOperations.disable, ({ id }, { caller }) => caller.kind === "system" ? service.disable(id) : Effect.fail(new PersonCallerDenied())),
+    bindOperation(PartyOperations.lockActive, (input, { caller }) => service
+        .lockActive(input)
+        .pipe(Effect.catchTag(["PrincipalKindRefused", "PrincipalDisabledRefused"], (error) => Effect.fail(caller.kind === "person" ? new PersonNotFound() : error)))),
+    bindOperation(PartyOperations.principalsByIds, ({ ids }) => service.principalsByIds(ids)),
+    bindOperation(PartyOperations.findPrincipal, (input) => service.findPrincipal(input)),
+    bindOperation(PartyOperations.holdersOf, (input) => service.holdersOf(input)),
+    bindOperation(PartyOperations.canAdminOrganisation, ({ organisationId }, { caller }) => service.canAdminOrganisation(caller, organisationId)),
+    bindOperation(PartyOperations.createInvitation, (input, { caller }) => service.createInvitation(caller, input)),
+    bindOperation(PartyOperations.acceptInvitation, ({ code }, { caller }) => service.acceptInvitation(caller, code)),
+    bindOperation(PartyOperations.revokeInvitation, ({ id }, { caller }) => service.revokeInvitation(caller, id)),
+    bindOperation(PartyOperations.listInvitations, ({ organisationId }, { caller }) => service.listInvitations(caller, organisationId)),
+    bindOperation(PartyOperations.myOrganisations, (_input, { caller }) => service.myOrganisations(caller)),
+    bindOperation(PartyOperations.listMembers, ({ organisationId }, { caller }) => service.listMembers(caller, organisationId)),
+    bindOperation(PartyOperations.listPeople, (_input, { caller }) => service.listPeople(caller)),
+    bindOperation(PartyOperations.myAccess, (_input, { caller }) => service.myAccess(caller)),
+    bindOperation(PartyOperations.createOrganisation, (input, { caller }) => service.createOrganisation(caller, input)),
+    bindOperation(PartyOperations.showOrganisation, ({ id }) => service.showOrganisation(id)),
+    bindOperation(PartyOperations.relate, (input, { caller }) => service.relate(caller, input)),
+    bindOperation(PartyOperations.unrelate, (input, { caller }) => service.unrelate(caller, input)),
+    bindOperation(PartyOperations.isRelated, (input) => service.isRelated(input)),
+    bindOperation(PartyOperations.defineRole, (input, { caller }) => service.defineRole(caller, input)),
+    bindOperation(PartyOperations.deleteRole, ({ key }, { caller }) => service.deleteRole(caller, key)),
+    bindOperation(PartyOperations.listRoles, (_input, { caller }) => service.listRoles(caller)),
+    bindOperation(PartyOperations.assignRole, (input, { caller }) => service.assignRole(caller, input)),
+    bindOperation(PartyOperations.revokeRole, (input, { caller }) => service.revokeRole(caller, input)),
+    bindOperation(PartyOperations.rolesOf, ({ personId }, { caller }) => service.rolesOf(caller, personId)),
+    bindOperation(PartyOperations.createPerson, (input, { caller }) => caller.kind === "system" ? service.createPerson(input) : Effect.fail(new PersonCallerDenied())),
+    bindOperation(PartyOperations.showPerson, ({ id }, { caller }) => caller.kind === "person" ? service.get(caller.actor, id) : Effect.fail(new PersonNotFound())),
+    bindOperation(PartyOperations.showMe, (_input, { caller }) => caller.kind === "person" ? service.me(caller.actor) : Effect.fail(new PersonNotFound())),
+    bindOperation(PartyOperations.renamePerson, ({ id, displayName }, { caller }) => caller.kind === "person"
+        ? service.rename(caller.actor, id, displayName)
+        : Effect.fail(new PersonUpdateRefused())),
+];

package/dist/person/operations.d.ts

@@ -0,0 +1,306 @@
+import { Schema } from "effect";
+import { PartyDenied, PartyNotFound, PartyUnavailable } from "../organisation/organisation.js";
+import { PersonAlreadyExists, PersonCallerDenied, PersonInputInvalid, PersonNotFound, PersonStoreUnavailable, PersonUpdateRefused } from "./person.js";
+export declare const PartyOperations: {
+    readonly canAdminOrganisation: import("@house-rules/domain/contract").Operation<"Party.canAdminOrganisation", Schema.Struct<{
+        readonly organisationId: Schema.String;
+    }>, Schema.Boolean, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly createInvitation: import("@house-rules/domain/contract").Operation<"Party.createInvitation", Schema.Struct<{
+        readonly organisationId: Schema.String;
+        readonly roleKey: Schema.NullOr<Schema.String>;
+    }>, Schema.Struct<{
+        readonly invitation: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly organisationId: Schema.String;
+            readonly roleKey: Schema.NullOr<Schema.String>;
+            readonly createdBy: Schema.brand<Schema.NonEmptyString, "ActorId">;
+            readonly expiresAt: Schema.Finite;
+            readonly state: Schema.Literals<readonly ["pending", "used", "revoked"]>;
+        }>;
+        readonly code: Schema.String;
+    }>, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly acceptInvitation: import("@house-rules/domain/contract").Operation<"Party.acceptInvitation", Schema.Struct<{
+        readonly code: Schema.String;
+    }>, Schema.Struct<{
+        readonly organisationId: Schema.String;
+        readonly roleKey: Schema.NullOr<Schema.String>;
+        readonly personId: Schema.brand<Schema.NonEmptyString, "ActorId">;
+    }>, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly revokeInvitation: import("@house-rules/domain/contract").Operation<"Party.revokeInvitation", Schema.Struct<{
+        readonly id: Schema.String;
+    }>, Schema.Void, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, true, true, true>;
+    readonly listInvitations: import("@house-rules/domain/contract").Operation<"Party.listInvitations", Schema.Struct<{
+        readonly organisationId: Schema.String;
+    }>, Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly organisationId: Schema.String;
+        readonly roleKey: Schema.NullOr<Schema.String>;
+        readonly createdBy: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly expiresAt: Schema.Finite;
+        readonly state: Schema.Literals<readonly ["pending", "used", "revoked"]>;
+    }>>, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly myOrganisations: import("@house-rules/domain/contract").Operation<"Party.myOrganisations", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly name: Schema.NonEmptyString;
+        readonly relation: Schema.NullOr<Schema.String>;
+        readonly roles: Schema.$Array<Schema.Struct<{
+            readonly roleKey: Schema.String;
+            readonly roleName: Schema.String;
+            readonly permissions: Schema.$Array<Schema.String>;
+        }>>;
+    }>>, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly myAccess: import("@house-rules/domain/contract").Operation<"Party.myAccess", Schema.$Record<Schema.String, Schema.Never>, Schema.Struct<{
+        readonly roles: Schema.$Array<Schema.Struct<{
+            readonly personId: Schema.brand<Schema.NonEmptyString, "ActorId">;
+            readonly roleKey: Schema.NonEmptyString;
+            readonly organisationId: Schema.NullOr<Schema.NonEmptyString>;
+        }>>;
+        readonly permissions: Schema.$Array<Schema.String>;
+        readonly catalogue: Schema.$Array<Schema.String>;
+    }>, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly createOrganisation: import("@house-rules/domain/contract").Operation<"Party.createOrganisation", Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly name: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly name: Schema.NonEmptyString;
+    }>, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly showOrganisation: import("@house-rules/domain/contract").Operation<"Party.showOrganisation", Schema.Struct<{
+        readonly id: Schema.String;
+    }>, Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly name: Schema.NonEmptyString;
+    }>, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly relate: import("@house-rules/domain/contract").Operation<"Party.relate", 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;
+    }>, Schema.Void, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly unrelate: import("@house-rules/domain/contract").Operation<"Party.unrelate", 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;
+    }>, Schema.Void, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, true, true, true>;
+    readonly isRelated: import("@house-rules/domain/contract").Operation<"Party.isRelated", 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;
+    }>, Schema.Boolean, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly defineRole: import("@house-rules/domain/contract").Operation<"Party.defineRole", Schema.Struct<{
+        readonly key: Schema.String;
+        readonly name: Schema.String;
+        readonly permissions: Schema.$Array<Schema.String>;
+        readonly organisationId: Schema.NullOr<Schema.String>;
+    }>, Schema.Struct<{
+        readonly key: Schema.NonEmptyString;
+        readonly name: Schema.NonEmptyString;
+        readonly permissions: Schema.$Array<Schema.String>;
+        readonly organisationId: Schema.NullOr<Schema.NonEmptyString>;
+        readonly builtIn: Schema.Boolean;
+    }>, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly deleteRole: import("@house-rules/domain/contract").Operation<"Party.deleteRole", Schema.Struct<{
+        readonly key: Schema.String;
+    }>, Schema.Void, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, true, true, true>;
+    readonly listRoles: import("@house-rules/domain/contract").Operation<"Party.listRoles", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
+        readonly key: Schema.NonEmptyString;
+        readonly name: Schema.NonEmptyString;
+        readonly permissions: Schema.$Array<Schema.String>;
+        readonly organisationId: Schema.NullOr<Schema.NonEmptyString>;
+        readonly builtIn: Schema.Boolean;
+    }>>, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly assignRole: import("@house-rules/domain/contract").Operation<"Party.assignRole", Schema.Struct<{
+        readonly personId: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly roleKey: Schema.NonEmptyString;
+        readonly organisationId: Schema.NullOr<Schema.NonEmptyString>;
+    }>, Schema.Void, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly revokeRole: import("@house-rules/domain/contract").Operation<"Party.revokeRole", Schema.Struct<{
+        readonly personId: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly roleKey: Schema.NonEmptyString;
+        readonly organisationId: Schema.NullOr<Schema.NonEmptyString>;
+    }>, Schema.Void, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, false, true, true, true>;
+    readonly rolesOf: import("@house-rules/domain/contract").Operation<"Party.rolesOf", Schema.Struct<{
+        readonly personId: Schema.brand<Schema.NonEmptyString, "ActorId">;
+    }>, Schema.$Array<Schema.Struct<{
+        readonly personId: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly roleKey: Schema.NonEmptyString;
+        readonly organisationId: Schema.NullOr<Schema.NonEmptyString>;
+    }>>, Schema.Union<readonly [typeof import("../organisation/organisation.js").PartyLastAdmin, typeof import("../organisation/organisation.js").PartyConflict, typeof PartyDenied, typeof import("../organisation/organisation.js").PartyInputInvalid, typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly createPrincipal: import("@house-rules/domain/contract").Operation<"Party.createPrincipal", Schema.Struct<{
+        readonly id: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "ActorId">>;
+        readonly displayName: Schema.String;
+        readonly kind: Schema.Literals<readonly ["person", "agent"]>;
+        readonly handle: Schema.String;
+        readonly createdBy: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "ActorId">>;
+    }>, Schema.Struct<{
+        readonly principal: Schema.Struct<{
+            readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+            readonly displayName: Schema.Trim;
+            readonly createdAt: Schema.Int;
+            readonly kind: Schema.Literals<readonly ["person", "agent"]>;
+            readonly handle: Schema.String;
+            readonly createdBy: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "ActorId">>;
+            readonly disabledAt: Schema.NullOr<Schema.Int>;
+        }>;
+        readonly fact: Schema.Struct<{
+            readonly kind: Schema.Literal<"principal.created">;
+            readonly after: Schema.Struct<{
+                readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+                readonly displayName: Schema.Trim;
+                readonly createdAt: Schema.Int;
+                readonly kind: Schema.Literals<readonly ["person", "agent"]>;
+                readonly handle: Schema.String;
+                readonly createdBy: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "ActorId">>;
+                readonly disabledAt: Schema.NullOr<Schema.Int>;
+            }>;
+        }>;
+    }>, Schema.Union<readonly [typeof PersonAlreadyExists, typeof PersonCallerDenied, typeof PersonInputInvalid, typeof PersonStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly disable: import("@house-rules/domain/contract").Operation<"Party.disable", Schema.Struct<{
+        readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+    }>, Schema.Struct<{
+        readonly principal: Schema.Struct<{
+            readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+            readonly displayName: Schema.Trim;
+            readonly createdAt: Schema.Int;
+            readonly kind: Schema.Literals<readonly ["person", "agent"]>;
+            readonly handle: Schema.String;
+            readonly createdBy: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "ActorId">>;
+            readonly disabledAt: Schema.NullOr<Schema.Int>;
+        }>;
+        readonly fact: Schema.NullOr<Schema.Struct<{
+            readonly kind: Schema.Literal<"principal.disabled">;
+            readonly before: Schema.Struct<{
+                readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+                readonly displayName: Schema.Trim;
+                readonly createdAt: Schema.Int;
+                readonly kind: Schema.Literals<readonly ["person", "agent"]>;
+                readonly handle: Schema.String;
+                readonly createdBy: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "ActorId">>;
+                readonly disabledAt: Schema.NullOr<Schema.Int>;
+            }>;
+            readonly after: Schema.Struct<{
+                readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+                readonly displayName: Schema.Trim;
+                readonly createdAt: Schema.Int;
+                readonly kind: Schema.Literals<readonly ["person", "agent"]>;
+                readonly handle: Schema.String;
+                readonly createdBy: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "ActorId">>;
+                readonly disabledAt: Schema.NullOr<Schema.Int>;
+            }>;
+        }>>;
+    }>, Schema.Union<readonly [typeof PersonNotFound, typeof PersonCallerDenied, typeof PersonStoreUnavailable]>, NoInfer<readonly []>, false, true, true, true>;
+    readonly lockActive: import("@house-rules/domain/contract").Operation<"Party.lockActive", Schema.Struct<{
+        readonly handle: Schema.String;
+        readonly kind: Schema.Literals<readonly ["person", "agent"]>;
+    }>, Schema.Struct<{
+        readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly displayName: Schema.Trim;
+        readonly createdAt: Schema.Int;
+        readonly kind: Schema.Literals<readonly ["person", "agent"]>;
+        readonly handle: Schema.String;
+        readonly createdBy: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "ActorId">>;
+        readonly disabledAt: Schema.NullOr<Schema.Int>;
+    }>, Schema.Union<readonly [typeof PersonNotFound, typeof import("./principal.ts").PrincipalKindRefused, typeof import("./principal.ts").PrincipalDisabledRefused, typeof PersonStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly principalsByIds: import("@house-rules/domain/contract").Operation<"Party.principalsByIds", Schema.Struct<{
+        readonly ids: Schema.$Array<Schema.brand<Schema.NonEmptyString, "ActorId">>;
+    }>, Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly displayName: Schema.Trim;
+        readonly createdAt: Schema.Int;
+        readonly kind: Schema.Literals<readonly ["person", "agent"]>;
+        readonly handle: Schema.String;
+        readonly createdBy: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "ActorId">>;
+        readonly disabledAt: Schema.NullOr<Schema.Int>;
+    }>>, typeof PersonStoreUnavailable, NoInfer<readonly []>, true, false, false, false>;
+    readonly findPrincipal: import("@house-rules/domain/contract").Operation<"Party.findPrincipal", Schema.Struct<{
+        readonly handle: Schema.String;
+    }>, Schema.Struct<{
+        readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly displayName: Schema.Trim;
+        readonly createdAt: Schema.Int;
+        readonly kind: Schema.Literals<readonly ["person", "agent"]>;
+        readonly handle: Schema.String;
+        readonly createdBy: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "ActorId">>;
+        readonly disabledAt: Schema.NullOr<Schema.Int>;
+    }>, Schema.Union<readonly [typeof PersonNotFound, typeof PersonStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly holdersOf: import("@house-rules/domain/contract").Operation<"Party.holdersOf", Schema.Struct<{
+        readonly role: Schema.NonEmptyString;
+        readonly scope: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+    }>, Schema.Struct<{
+        readonly ids: Schema.$Array<Schema.brand<Schema.NonEmptyString, "ActorId">>;
+        readonly truncated: Schema.Boolean;
+    }>, typeof PartyUnavailable, NoInfer<readonly []>, true, false, false, false>;
+    readonly listMembers: import("@house-rules/domain/contract").Operation<"Party.listMembers", Schema.Struct<{
+        readonly organisationId: Schema.String;
+    }>, Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly displayName: Schema.Trim;
+        readonly createdAt: Schema.Int;
+        readonly relation: Schema.NullOr<Schema.String>;
+        readonly roles: Schema.$Array<Schema.Struct<{
+            readonly roleKey: Schema.String;
+            readonly roleName: Schema.String;
+        }>>;
+    }>>, Schema.Union<readonly [typeof PartyNotFound, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly listPeople: import("@house-rules/domain/contract").Operation<"Party.listPeople", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly displayName: Schema.Trim;
+        readonly createdAt: Schema.Int;
+        readonly assignments: Schema.$Array<Schema.Struct<{
+            readonly roleKey: Schema.String;
+            readonly roleName: Schema.String;
+            readonly organisationId: Schema.NullOr<Schema.String>;
+            readonly organisationName: Schema.NullOr<Schema.String>;
+        }>>;
+        readonly organisations: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly name: Schema.NonEmptyString;
+            readonly relation: Schema.String;
+        }>>;
+    }>>, Schema.Union<readonly [typeof PartyDenied, typeof PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly createPerson: import("@house-rules/domain/contract").Operation<"Party.createPerson", Schema.Struct<{
+        readonly displayName: Schema.String;
+        readonly id: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "ActorId">>;
+    }>, Schema.Struct<{
+        readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly displayName: Schema.Trim;
+        readonly createdAt: Schema.Int;
+    }>, Schema.Union<readonly [typeof PersonAlreadyExists, typeof PersonCallerDenied, typeof PersonInputInvalid, typeof PersonStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly showPerson: import("@house-rules/domain/contract").Operation<"Party.showPerson", Schema.Struct<{
+        readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+    }>, Schema.Struct<{
+        readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly displayName: Schema.Trim;
+        readonly createdAt: Schema.Int;
+    }>, Schema.Union<readonly [typeof PersonNotFound, typeof PersonStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly showMe: import("@house-rules/domain/contract").Operation<"Party.showMe", Schema.$Record<Schema.String, Schema.Never>, Schema.Struct<{
+        readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly displayName: Schema.Trim;
+        readonly createdAt: Schema.Int;
+    }>, Schema.Union<readonly [typeof PersonNotFound, typeof PersonStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly renamePerson: import("@house-rules/domain/contract").Operation<"Party.renamePerson", Schema.Struct<{
+        readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly displayName: Schema.String;
+    }>, Schema.Struct<{
+        readonly id: Schema.brand<Schema.NonEmptyString, "ActorId">;
+        readonly displayName: Schema.Trim;
+        readonly createdAt: Schema.Int;
+    }>, Schema.Union<readonly [typeof PersonInputInvalid, typeof PersonNotFound, typeof PersonUpdateRefused, typeof PersonStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+};