@house-rules/party 0.0.0-stage → 0.1.1

package/dist/adapters/postgres/person.js

@@ -0,0 +1,63 @@
+import { UnitOfWork } from "@house-rules/domain";
+import { Effect, Layer, Schema } from "effect";
+import { SqlClient } from "effect/sql/SqlClient";
+import { Person, PersonStoreUnavailable } from "../../person/person.js";
+import { PersonStore } from "../../storage.js";
+import { legacyPrincipal, Principal } from "../../person/principal.js";
+const decodeRows = Schema.decodeUnknownEffect(Schema.Array(Person));
+const unavailable = (cause) => new PersonStoreUnavailable({ cause });
+export const postgresPersonStore = Layer.effect(PersonStore, Effect.gen(function* postgresPersonStore() {
+    const sql = yield* SqlClient;
+    const columns = sql.literal(`id, display_name as "displayName", floor(extract(epoch from created_at) * 1000)::float8 as "createdAt"`);
+    const read = (query) => query.pipe(Effect.flatMap(decodeRows), Effect.mapError(unavailable));
+    const principalColumns = sql.literal(`id, display_name as "displayName", floor(extract(epoch from created_at) * 1000)::float8 as "createdAt",
+       kind, handle, created_by as "createdBy", floor(extract(epoch from disabled_at) * 1000)::float8 as "disabledAt"`);
+    const readPrincipals = (query) => query.pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.Array(Principal))), Effect.mapError(unavailable));
+    const insertPrincipal = Effect.fn("PersonStore.postgres.insertPrincipal")(function* (principal) {
+        yield* UnitOfWork.required;
+        const rows = yield* sql `insert into party_person (id, display_name, created_at, kind, handle, created_by, disabled_at)
+        values (${principal.id}, ${principal.displayName},
+          'epoch'::timestamptz + ${principal.createdAt}::bigint * interval '1 millisecond',
+          ${principal.kind}, ${principal.handle}, ${principal.createdBy},
+          'epoch'::timestamptz + ${principal.disabledAt}::bigint * interval '1 millisecond')
+        on conflict do nothing returning id`.pipe(Effect.mapError(unavailable));
+        return rows.length > 0;
+    });
+    return PersonStore.of({
+        principal: (id) => readPrincipals(sql `select ${principalColumns} from party_person where id = ${id}`).pipe(Effect.map((rows) => rows[0])),
+        principalByHandle: (handle) => readPrincipals(sql `select ${principalColumns} from party_person where handle = ${handle}`).pipe(Effect.map((rows) => rows[0])),
+        principalsByIds: (ids) => readPrincipals(sql `select ${principalColumns} from party_person where ${sql.in("id", ids)} order by id`),
+        insertPrincipal,
+        lockPrincipal: Effect.fn("PersonStore.postgres.lockPrincipal")(function* (handle) {
+            yield* UnitOfWork.required;
+            // FOR KEY SHARE would not block an UPDATE of disabled_at.
+            const rows = yield* readPrincipals(sql `select ${principalColumns} from party_person where handle = ${handle} for share`);
+            return rows[0];
+        }),
+        principalForUpdate: Effect.fn("PersonStore.postgres.principalForUpdate")(function* (id) {
+            yield* UnitOfWork.required;
+            const rows = yield* readPrincipals(sql `select ${principalColumns} from party_person where id = ${id} for no key update`);
+            return rows[0];
+        }),
+        disable: Effect.fn("PersonStore.postgres.disable")(function* (id, disabledAt) {
+            yield* UnitOfWork.required;
+            const rows = yield* readPrincipals(sql `update party_person
+          set disabled_at = coalesce(disabled_at, 'epoch'::timestamptz + ${disabledAt}::bigint * interval '1 millisecond')
+          where id = ${id} returning ${principalColumns}`);
+            return rows[0];
+        }),
+        find: (id) => read(sql `select ${columns} from party_person where id = ${id}`).pipe(Effect.map((rows) => rows[0])),
+        list: (ids) => read(sql `select ${columns} from party_person where ${ids === null ? sql `true` : sql.in("id", ids)} order by display_name, id`),
+        insertIfFree: (person) => insertPrincipal(legacyPrincipal(person)),
+        rename: Effect.fn("PersonStore.postgres.rename")(function* (id, displayName) {
+            yield* UnitOfWork.required;
+            const rows = yield* read(sql `update party_person set display_name = ${displayName}
+            where id = ${id} returning ${columns}`);
+            return rows[0];
+        }),
+        erase: Effect.fn("PersonStore.postgres.erase")(function* (id) {
+            yield* UnitOfWork.required;
+            yield* sql `delete from party_person where id = ${id}`.pipe(Effect.mapError(unavailable));
+        }),
+    });
+}));

package/dist/assignment/assignment.d.ts

@@ -0,0 +1,13 @@
+import { Effect, Schema } from "effect";
+import { PartyInputInvalid } from "../organisation/organisation.js";
+export declare const Assignment: Schema.Struct<{
+    readonly personId: Schema.brand<Schema.NonEmptyString, "ActorId">;
+    readonly roleKey: Schema.NonEmptyString;
+    readonly organisationId: Schema.NullOr<Schema.NonEmptyString>;
+}>;
+export type Assignment = typeof Assignment.Type;
+export declare const validateAssignment: (input: Assignment) => Effect.Effect<{
+    readonly personId: string & import("effect/Brand").Brand<"ActorId">;
+    readonly roleKey: string;
+    readonly organisationId: string | null;
+}, PartyInputInvalid, never>;

package/dist/assignment/assignment.js

@@ -0,0 +1,9 @@
+import { ActorId } from "@house-rules/domain/contract";
+import { Effect, Schema } from "effect";
+import { PartyInputInvalid } from "../organisation/organisation.js";
+export const Assignment = Schema.Struct({
+    personId: ActorId,
+    roleKey: Schema.NonEmptyString,
+    organisationId: Schema.NullOr(Schema.NonEmptyString),
+});
+export const validateAssignment = (input) => Schema.decodeEffect(Assignment)(input).pipe(Effect.mapError(() => new PartyInputInvalid({ message: "Invalid role assignment." })));

package/dist/assignment/holders.d.ts

@@ -0,0 +1,11 @@
+import { Effect } from "effect";
+import type { PartyStore } from "../storage.js";
+export declare const makeHolders: (store: PartyStore["Service"], limit: number) => {
+    holdersOf: (input: {
+        readonly role: string;
+        readonly scope?: string | null;
+    }) => Effect.Effect<{
+        ids: (string & import("effect/Brand").Brand<"ActorId">)[];
+        truncated: boolean;
+    }, import("../contract.ts").PartyUnavailable, never>;
+};

package/dist/assignment/holders.js

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+export const makeHolders = (store, limit) => ({
+    holdersOf: Effect.fn("Party.holdersOf")(function* (input) {
+        const ids = yield* store.holderIds(input.role, input.scope ?? null, limit + 1);
+        return { ids: ids.slice(0, limit), truncated: ids.length > limit };
+    }),
+});

package/dist/contract.d.ts

@@ -0,0 +1,9 @@
+export { Invitation, CreatedInvitation, InvitationAcceptance } from "./invitation/invitation.js";
+export { Assignment } from "./assignment/assignment.js";
+export { Organisation, OrganisationId, PartyNotFound, PartyInputInvalid, PartyDenied, PartyConflict, PartyLastAdmin, PartyUnavailable, } from "./organisation/organisation.js";
+export { Relationship, PartyReference } from "./relationship/relationship.js";
+export { Role, RoleKey, RolePermission, type BuiltInRoles, type PartyOptions, } from "./role/role.js";
+export { DisplayName, Person, PersonAlreadyExists, PersonCallerDenied, PersonInputInvalid, PersonNotFound, PersonStoreUnavailable, PersonUpdateRefused, } from "./person/person.js";
+export { type PartyPermission, PartyPermissions } from "./person/permissions.js";
+export { PartyOperations } from "./person/operations.js";
+export { Principal, PrincipalKind, PrincipalHandle, CreatePrincipal, CreatedPrincipal, DisabledPrincipal, PrincipalCreated, PrincipalDisabled, PrincipalKindRefused, PrincipalDisabledRefused, } from "./person/principal.js";

package/dist/contract.js

@@ -0,0 +1,9 @@
+export { Invitation, CreatedInvitation, InvitationAcceptance } from "./invitation/invitation.js";
+export { Assignment } from "./assignment/assignment.js";
+export { Organisation, OrganisationId, PartyNotFound, PartyInputInvalid, PartyDenied, PartyConflict, PartyLastAdmin, PartyUnavailable, } from "./organisation/organisation.js";
+export { Relationship, PartyReference } from "./relationship/relationship.js";
+export { Role, RoleKey, RolePermission, } from "./role/role.js";
+export { DisplayName, Person, PersonAlreadyExists, PersonCallerDenied, PersonInputInvalid, PersonNotFound, PersonStoreUnavailable, PersonUpdateRefused, } from "./person/person.js";
+export { PartyPermissions } from "./person/permissions.js";
+export { PartyOperations } from "./person/operations.js";
+export { Principal, PrincipalKind, PrincipalHandle, CreatePrincipal, CreatedPrincipal, DisabledPrincipal, PrincipalCreated, PrincipalDisabled, PrincipalKindRefused, PrincipalDisabledRefused, } from "./person/principal.js";

package/dist/facade.d.ts

@@ -0,0 +1,22 @@
+import type { MaySocket } from "@house-rules/application";
+import { Effect, Layer } from "effect";
+import { PartyInputInvalid } from "./organisation/organisation.js";
+import { makeParty } from "./person/party.js";
+import { makePrincipals } from "./person/principals.js";
+import { makeAccess } from "./role/access.js";
+import type { PartyOptions } from "./role/role.js";
+import { PartyStore, PersonStore } from "./storage.js";
+type PartyService = ReturnType<typeof makeParty> & ReturnType<typeof makeAccess> & ReturnType<typeof makePrincipals>;
+export type PartyFailure = Effect.Error<ReturnType<PartyService[keyof PartyService]>>;
+declare const Party_base: import("effect/Context").ServiceClass<Party, "party", PartyService> & {
+    readonly id: "party";
+} & {
+    readonly make: (options: PartyOptions) => Effect.Effect<PartyService, PartyInputInvalid, PartyStore | PersonStore>;
+    readonly layer: (options: PartyOptions) => import("@house-rules/domain").ModuleLayer<Party, PartyInputInvalid, PartyStore | PersonStore>;
+};
+export declare class Party extends Party_base {
+    static readonly layerMemory: (options: PartyOptions) => Layer.Layer<Party, PartyInputInvalid, never>;
+    static readonly layerPostgres: (options: PartyOptions) => Layer.Layer<Party, PartyInputInvalid, import("effect/sql/SqlClient").SqlClient>;
+    static readonly may: (_options?: Record<never, never>) => Effect.Effect<MaySocket<import("./organisation/organisation.js").PartyUnavailable>, never, Party>;
+}
+export {};

package/dist/facade.js

@@ -0,0 +1,35 @@
+import { defineModule } from "@house-rules/domain";
+import { Effect, Layer, Option, Schema } from "effect";
+import { memoryPersonStore } from "./adapters/memory/person.js";
+import { postgresPersonStore } from "./adapters/postgres/person.js";
+import { memoryPartyStore } from "./adapters/memory/party.js";
+import { postgresPartyStore } from "./adapters/postgres/party.js";
+import { PartyInputInvalid, PartyUnavailable } from "./organisation/organisation.js";
+import { makeParty } from "./person/party.js";
+import { makePrincipals } from "./person/principals.js";
+import { makeAccess } from "./role/access.js";
+import { PermissionCatalogue } from "@house-rules/application";
+import { PartyStore, PersonStore } from "./storage.js";
+export class Party extends defineModule()("party", {
+    make: (options) => Effect.gen(function* () {
+        const holdersLimit = yield* Schema.decodeEffect(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER - 1)))(options.holdersLimit ?? 1000).pipe(Effect.mapError(() => new PartyInputInvalid({ message: "Invalid holders limit." })));
+        const persons = yield* PersonStore;
+        const store = yield* PartyStore;
+        const catalogue = Option.getOrUndefined(yield* Effect.serviceOption(PermissionCatalogue));
+        return {
+            ...makeParty(persons),
+            ...makePrincipals(persons, options),
+            ...makeAccess(store, {
+                find: (id) => persons.find(id).pipe(Effect.mapError((cause) => new PartyUnavailable({ cause }))),
+                principal: (id) => persons
+                    .principal(id)
+                    .pipe(Effect.mapError((cause) => new PartyUnavailable({ cause }))),
+                list: (ids) => persons.list(ids).pipe(Effect.mapError((cause) => new PartyUnavailable({ cause }))),
+            }, { ...options, holdersLimit }, catalogue),
+        };
+    }),
+}) {
+    static layerMemory = (options) => this.layer(options).pipe(Layer.provide(Layer.merge(memoryPersonStore(), memoryPartyStore())));
+    static layerPostgres = (options) => this.layer(options).pipe(Layer.provide(Layer.merge(postgresPersonStore, postgresPartyStore)));
+    static may = (_options) => Effect.map(Party, (party) => ({ permissionsOf: party.permissionsOf }));
+}

package/dist/index.d.ts

@@ -0,0 +1,294 @@
+export { Principal, PrincipalKind, PrincipalHandle, CreatePrincipal, CreatedPrincipal, DisabledPrincipal, PrincipalCreated, PrincipalDisabled, PrincipalKindRefused, PrincipalDisabledRefused, } from "./contract.js";
+export { bindParty } from "./person/bind-party.js";
+export { Party, type PartyFailure } from "./facade.js";
+export { PartyStore, PersonStore } from "./storage.js";
+import { Party } from "./facade.js";
+import { bindParty } from "./person/bind-party.js";
+export declare const PartyMount: {
+    map: {
+        name: string;
+        kind: "package";
+        package: string;
+    };
+    service: typeof Party;
+    operations: (import("@house-rules/domain").Operation<"Party.acceptInvitation", import("effect/Schema").Struct<{
+        readonly code: import("effect/Schema").String;
+    }>, import("effect/Schema").Struct<{
+        readonly organisationId: import("effect/Schema").String;
+        readonly roleKey: import("effect/Schema").NullOr<import("effect/Schema").String>;
+        readonly personId: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Party.assignRole", import("effect/Schema").Struct<{
+        readonly personId: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+        readonly roleKey: import("effect/Schema").NonEmptyString;
+        readonly organisationId: import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>;
+    }>, import("effect/Schema").Void, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Party.canAdminOrganisation", import("effect/Schema").Struct<{
+        readonly organisationId: import("effect/Schema").String;
+    }>, import("effect/Schema").Boolean, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Party.createInvitation", import("effect/Schema").Struct<{
+        readonly organisationId: import("effect/Schema").String;
+        readonly roleKey: import("effect/Schema").NullOr<import("effect/Schema").String>;
+    }>, import("effect/Schema").Struct<{
+        readonly invitation: import("effect/Schema").Struct<{
+            readonly id: import("effect/Schema").String;
+            readonly organisationId: import("effect/Schema").String;
+            readonly roleKey: import("effect/Schema").NullOr<import("effect/Schema").String>;
+            readonly createdBy: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+            readonly expiresAt: import("effect/Schema").Finite;
+            readonly state: import("effect/Schema").Literals<readonly ["pending", "used", "revoked"]>;
+        }>;
+        readonly code: import("effect/Schema").String;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Party.createOrganisation", import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").NonEmptyString;
+        readonly name: import("effect/Schema").NonEmptyString;
+    }>, import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").NonEmptyString;
+        readonly name: import("effect/Schema").NonEmptyString;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Party.createPerson", import("effect/Schema").Struct<{
+        readonly displayName: import("effect/Schema").String;
+        readonly id: import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">>;
+    }>, import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+        readonly displayName: import("effect/Schema").Trim;
+        readonly createdAt: import("effect/Schema").Int;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PersonAlreadyExists, typeof import("./contract.js").PersonCallerDenied, typeof import("./contract.js").PersonInputInvalid, typeof import("./contract.js").PersonStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Party.createPrincipal", import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">>;
+        readonly displayName: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").Literals<readonly ["person", "agent"]>;
+        readonly handle: import("effect/Schema").String;
+        readonly createdBy: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">>;
+    }>, import("effect/Schema").Struct<{
+        readonly principal: import("effect/Schema").Struct<{
+            readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+            readonly displayName: import("effect/Schema").Trim;
+            readonly createdAt: import("effect/Schema").Int;
+            readonly kind: import("effect/Schema").Literals<readonly ["person", "agent"]>;
+            readonly handle: import("effect/Schema").String;
+            readonly createdBy: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">>;
+            readonly disabledAt: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+        }>;
+        readonly fact: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").Literal<"principal.created">;
+            readonly after: import("effect/Schema").Struct<{
+                readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+                readonly displayName: import("effect/Schema").Trim;
+                readonly createdAt: import("effect/Schema").Int;
+                readonly kind: import("effect/Schema").Literals<readonly ["person", "agent"]>;
+                readonly handle: import("effect/Schema").String;
+                readonly createdBy: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">>;
+                readonly disabledAt: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+            }>;
+        }>;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PersonAlreadyExists, typeof import("./contract.js").PersonCallerDenied, typeof import("./contract.js").PersonInputInvalid, typeof import("./contract.js").PersonStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Party.defineRole", import("effect/Schema").Struct<{
+        readonly key: import("effect/Schema").String;
+        readonly name: import("effect/Schema").String;
+        readonly permissions: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly organisationId: import("effect/Schema").NullOr<import("effect/Schema").String>;
+    }>, import("effect/Schema").Struct<{
+        readonly key: import("effect/Schema").NonEmptyString;
+        readonly name: import("effect/Schema").NonEmptyString;
+        readonly permissions: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly organisationId: import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>;
+        readonly builtIn: import("effect/Schema").Boolean;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Party.deleteRole", import("effect/Schema").Struct<{
+        readonly key: import("effect/Schema").String;
+    }>, import("effect/Schema").Void, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, false, true, true, true> | import("@house-rules/domain").Operation<"Party.disable", import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+    }>, import("effect/Schema").Struct<{
+        readonly principal: import("effect/Schema").Struct<{
+            readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+            readonly displayName: import("effect/Schema").Trim;
+            readonly createdAt: import("effect/Schema").Int;
+            readonly kind: import("effect/Schema").Literals<readonly ["person", "agent"]>;
+            readonly handle: import("effect/Schema").String;
+            readonly createdBy: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">>;
+            readonly disabledAt: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+        }>;
+        readonly fact: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").Literal<"principal.disabled">;
+            readonly before: import("effect/Schema").Struct<{
+                readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+                readonly displayName: import("effect/Schema").Trim;
+                readonly createdAt: import("effect/Schema").Int;
+                readonly kind: import("effect/Schema").Literals<readonly ["person", "agent"]>;
+                readonly handle: import("effect/Schema").String;
+                readonly createdBy: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">>;
+                readonly disabledAt: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+            }>;
+            readonly after: import("effect/Schema").Struct<{
+                readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+                readonly displayName: import("effect/Schema").Trim;
+                readonly createdAt: import("effect/Schema").Int;
+                readonly kind: import("effect/Schema").Literals<readonly ["person", "agent"]>;
+                readonly handle: import("effect/Schema").String;
+                readonly createdBy: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">>;
+                readonly disabledAt: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+            }>;
+        }>>;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PersonNotFound, typeof import("./contract.js").PersonCallerDenied, typeof import("./contract.js").PersonStoreUnavailable]>, NoInfer<readonly []>, false, true, true, true> | import("@house-rules/domain").Operation<"Party.findPrincipal", import("effect/Schema").Struct<{
+        readonly handle: import("effect/Schema").String;
+    }>, import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+        readonly displayName: import("effect/Schema").Trim;
+        readonly createdAt: import("effect/Schema").Int;
+        readonly kind: import("effect/Schema").Literals<readonly ["person", "agent"]>;
+        readonly handle: import("effect/Schema").String;
+        readonly createdBy: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">>;
+        readonly disabledAt: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PersonNotFound, typeof import("./contract.js").PersonStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Party.holdersOf", import("effect/Schema").Struct<{
+        readonly role: import("effect/Schema").NonEmptyString;
+        readonly scope: import("effect/Schema").optionalKey<import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>>;
+    }>, import("effect/Schema").Struct<{
+        readonly ids: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">>;
+        readonly truncated: import("effect/Schema").Boolean;
+    }>, typeof import("./contract.js").PartyUnavailable, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Party.isRelated", import("effect/Schema").Struct<{
+        readonly from: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").Literals<readonly ["person", "organisation"]>;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>;
+        readonly to: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").Literals<readonly ["person", "organisation"]>;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>;
+        readonly kind: import("effect/Schema").NonEmptyString;
+    }>, import("effect/Schema").Boolean, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Party.listInvitations", import("effect/Schema").Struct<{
+        readonly organisationId: import("effect/Schema").String;
+    }>, import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").String;
+        readonly organisationId: import("effect/Schema").String;
+        readonly roleKey: import("effect/Schema").NullOr<import("effect/Schema").String>;
+        readonly createdBy: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+        readonly expiresAt: import("effect/Schema").Finite;
+        readonly state: import("effect/Schema").Literals<readonly ["pending", "used", "revoked"]>;
+    }>>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Party.listMembers", import("effect/Schema").Struct<{
+        readonly organisationId: import("effect/Schema").String;
+    }>, import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+        readonly displayName: import("effect/Schema").Trim;
+        readonly createdAt: import("effect/Schema").Int;
+        readonly relation: import("effect/Schema").NullOr<import("effect/Schema").String>;
+        readonly roles: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly roleKey: import("effect/Schema").String;
+            readonly roleName: import("effect/Schema").String;
+        }>>;
+    }>>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Party.listPeople", import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Never>, import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+        readonly displayName: import("effect/Schema").Trim;
+        readonly createdAt: import("effect/Schema").Int;
+        readonly assignments: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly roleKey: import("effect/Schema").String;
+            readonly roleName: import("effect/Schema").String;
+            readonly organisationId: import("effect/Schema").NullOr<import("effect/Schema").String>;
+            readonly organisationName: import("effect/Schema").NullOr<import("effect/Schema").String>;
+        }>>;
+        readonly organisations: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly id: import("effect/Schema").NonEmptyString;
+            readonly name: import("effect/Schema").NonEmptyString;
+            readonly relation: import("effect/Schema").String;
+        }>>;
+    }>>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Party.listRoles", import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Never>, import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly key: import("effect/Schema").NonEmptyString;
+        readonly name: import("effect/Schema").NonEmptyString;
+        readonly permissions: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly organisationId: import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>;
+        readonly builtIn: import("effect/Schema").Boolean;
+    }>>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Party.lockActive", import("effect/Schema").Struct<{
+        readonly handle: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").Literals<readonly ["person", "agent"]>;
+    }>, import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+        readonly displayName: import("effect/Schema").Trim;
+        readonly createdAt: import("effect/Schema").Int;
+        readonly kind: import("effect/Schema").Literals<readonly ["person", "agent"]>;
+        readonly handle: import("effect/Schema").String;
+        readonly createdBy: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">>;
+        readonly disabledAt: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PersonNotFound, typeof import("./contract.js").PrincipalKindRefused, typeof import("./contract.js").PrincipalDisabledRefused, typeof import("./contract.js").PersonStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Party.myAccess", import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Never>, import("effect/Schema").Struct<{
+        readonly roles: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly personId: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+            readonly roleKey: import("effect/Schema").NonEmptyString;
+            readonly organisationId: import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>;
+        }>>;
+        readonly permissions: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly catalogue: import("effect/Schema").$Array<import("effect/Schema").String>;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Party.myOrganisations", import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Never>, import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").NonEmptyString;
+        readonly name: import("effect/Schema").NonEmptyString;
+        readonly relation: import("effect/Schema").NullOr<import("effect/Schema").String>;
+        readonly roles: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly roleKey: import("effect/Schema").String;
+            readonly roleName: import("effect/Schema").String;
+            readonly permissions: import("effect/Schema").$Array<import("effect/Schema").String>;
+        }>>;
+    }>>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Party.principalsByIds", import("effect/Schema").Struct<{
+        readonly ids: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">>;
+    }>, import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+        readonly displayName: import("effect/Schema").Trim;
+        readonly createdAt: import("effect/Schema").Int;
+        readonly kind: import("effect/Schema").Literals<readonly ["person", "agent"]>;
+        readonly handle: import("effect/Schema").String;
+        readonly createdBy: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">>;
+        readonly disabledAt: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+    }>>, typeof import("./contract.js").PersonStoreUnavailable, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Party.relate", import("effect/Schema").Struct<{
+        readonly from: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").Literals<readonly ["person", "organisation"]>;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>;
+        readonly to: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").Literals<readonly ["person", "organisation"]>;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>;
+        readonly kind: import("effect/Schema").NonEmptyString;
+    }>, import("effect/Schema").Void, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Party.renamePerson", import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+        readonly displayName: import("effect/Schema").String;
+    }>, import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+        readonly displayName: import("effect/Schema").Trim;
+        readonly createdAt: import("effect/Schema").Int;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PersonInputInvalid, typeof import("./contract.js").PersonNotFound, typeof import("./contract.js").PersonUpdateRefused, typeof import("./contract.js").PersonStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Party.revokeInvitation", import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").String;
+    }>, import("effect/Schema").Void, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, false, true, true, true> | import("@house-rules/domain").Operation<"Party.revokeRole", import("effect/Schema").Struct<{
+        readonly personId: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+        readonly roleKey: import("effect/Schema").NonEmptyString;
+        readonly organisationId: import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>;
+    }>, import("effect/Schema").Void, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, false, true, true, true> | import("@house-rules/domain").Operation<"Party.rolesOf", import("effect/Schema").Struct<{
+        readonly personId: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+    }>, import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly personId: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+        readonly roleKey: import("effect/Schema").NonEmptyString;
+        readonly organisationId: import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>;
+    }>>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Party.showMe", import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Never>, import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+        readonly displayName: import("effect/Schema").Trim;
+        readonly createdAt: import("effect/Schema").Int;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PersonNotFound, typeof import("./contract.js").PersonStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Party.showOrganisation", import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").String;
+    }>, import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").NonEmptyString;
+        readonly name: import("effect/Schema").NonEmptyString;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Party.showPerson", import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+    }>, import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").NonEmptyString, "ActorId">;
+        readonly displayName: import("effect/Schema").Trim;
+        readonly createdAt: import("effect/Schema").Int;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").PersonNotFound, typeof import("./contract.js").PersonStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Party.unrelate", import("effect/Schema").Struct<{
+        readonly from: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").Literals<readonly ["person", "organisation"]>;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>;
+        readonly to: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").Literals<readonly ["person", "organisation"]>;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>;
+        readonly kind: import("effect/Schema").NonEmptyString;
+    }>, import("effect/Schema").Void, import("effect/Schema").Union<readonly [typeof import("./contract.js").PartyLastAdmin, typeof import("./contract.js").PartyConflict, typeof import("./contract.js").PartyDenied, typeof import("./contract.js").PartyInputInvalid, typeof import("./contract.js").PartyNotFound, typeof import("./contract.js").PartyUnavailable]>, NoInfer<readonly []>, false, true, true, true>)[];
+    bind: typeof bindParty;
+};
+export { memoryPartyStore } from "./adapters/memory/party.js";
+export { postgresPartyStore } from "./adapters/postgres/party.js";
+export { Assignment, Organisation, OrganisationId, PartyNotFound, PartyInputInvalid, PartyDenied, PartyConflict, PartyLastAdmin, PartyUnavailable, Relationship, PartyReference, Role, RoleKey, RolePermission, type BuiltInRoles, type PartyOptions, } from "./contract.js";
+export { personPolicy } from "./person/policy.js";
+export { memoryPersonStore } from "./adapters/memory/person.js";
+export { postgresPersonStore } from "./adapters/postgres/person.js";
+export { DisplayName, type PartyPermission, PartyPermissions, Person, PersonAlreadyExists, PersonCallerDenied, PartyOperations, PersonInputInvalid, PersonNotFound, PersonStoreUnavailable, PersonUpdateRefused, } from "./contract.js";

package/dist/index.js

@@ -0,0 +1,20 @@
+export { Principal, PrincipalKind, PrincipalHandle, CreatePrincipal, CreatedPrincipal, DisabledPrincipal, PrincipalCreated, PrincipalDisabled, PrincipalKindRefused, PrincipalDisabledRefused, } from "./contract.js";
+export { bindParty } from "./person/bind-party.js";
+export { Party } from "./facade.js";
+export { PartyStore, PersonStore } from "./storage.js";
+import { Party } from "./facade.js";
+import { PartyOperations } from "./contract.js";
+import { bindParty } from "./person/bind-party.js";
+export const PartyMount = {
+    map: { name: "party", kind: "package", package: "@house-rules/party" },
+    service: Party,
+    operations: Object.values(PartyOperations),
+    bind: bindParty,
+};
+export { memoryPartyStore } from "./adapters/memory/party.js";
+export { postgresPartyStore } from "./adapters/postgres/party.js";
+export { Assignment, Organisation, OrganisationId, PartyNotFound, PartyInputInvalid, PartyDenied, PartyConflict, PartyLastAdmin, PartyUnavailable, Relationship, PartyReference, Role, RoleKey, RolePermission, } from "./contract.js";
+export { personPolicy } from "./person/policy.js";
+export { memoryPersonStore } from "./adapters/memory/person.js";
+export { postgresPersonStore } from "./adapters/postgres/person.js";
+export { DisplayName, PartyPermissions, Person, PersonAlreadyExists, PersonCallerDenied, PartyOperations, PersonInputInvalid, PersonNotFound, PersonStoreUnavailable, PersonUpdateRefused, } from "./contract.js";

package/dist/invitation/invitation.d.ts

@@ -0,0 +1,36 @@
+import { Schema } from "effect";
+export declare const 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"]>;
+}>;
+export type Invitation = typeof Invitation.Type;
+export declare const StoredInvitation: 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 codeHash: Schema.String;
+}>;
+export type StoredInvitation = typeof StoredInvitation.Type;
+export declare const InvitationAcceptance: Schema.Struct<{
+    readonly organisationId: Schema.String;
+    readonly roleKey: Schema.NullOr<Schema.String>;
+    readonly personId: Schema.brand<Schema.NonEmptyString, "ActorId">;
+}>;
+export declare const CreatedInvitation: 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;
+}>;

package/dist/invitation/invitation.js

@@ -0,0 +1,17 @@
+import { ActorId } from "@house-rules/domain/contract";
+import { Schema } from "effect";
+export const Invitation = Schema.Struct({
+    id: Schema.String,
+    organisationId: Schema.String,
+    roleKey: Schema.NullOr(Schema.String),
+    createdBy: ActorId,
+    expiresAt: Schema.Finite,
+    state: Schema.Literals(["pending", "used", "revoked"]),
+});
+export const StoredInvitation = Schema.Struct({ ...Invitation.fields, codeHash: Schema.String });
+export const InvitationAcceptance = Schema.Struct({
+    organisationId: Schema.String,
+    roleKey: Schema.NullOr(Schema.String),
+    personId: ActorId,
+});
+export const CreatedInvitation = Schema.Struct({ invitation: Invitation, code: Schema.String });