@stevenkellner/team-conduct-api 1.0.31 → 1.0.33

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stevenkellner/team-conduct-api",
-    "version": "1.0.31",
+    "version": "1.0.33",
     "description": "Firebase API for Team Conduct",
     "license": "MIT",
     "author": "Steven Kellner",
@@ -22,21 +22,21 @@
         "release": "npm run rebuild && npm run lint && npm version patch && git push --follow-tags"
     },
     "dependencies": {
-        "@stevenkellner/firebase-function": "^1.4.140",
-        "@stevenkellner/typescript-common-functionality": "^1.0.56"
+        "@stevenkellner/firebase-function": "^1.4.141",
+        "@stevenkellner/typescript-common-functionality": "^1.0.61"
     },
     "devDependencies": {
         "@assertive-ts/core": "^2.1.0",
-        "@eslint/compat": "^1.2.9",
+        "@eslint/compat": "^1.3.1",
         "@eslint/eslintrc": "^3.3.1",
-        "@eslint/js": "^9.27.0",
+        "@eslint/js": "^9.30.0",
         "@types/mocha": "^10.0.10",
-        "@typescript-eslint/eslint-plugin": "^8.32.1",
-        "@typescript-eslint/parser": "^8.32.1",
-        "eslint": "^9.27.0",
+        "@typescript-eslint/eslint-plugin": "^8.35.0",
+        "@typescript-eslint/parser": "^8.35.0",
+        "eslint": "^9.30.0",
         "eslint-config-google": "^0.14.0",
-        "eslint-plugin-import": "^2.31.0",
-        "mocha": "^11.3.0",
+        "eslint-plugin-import": "^2.32.0",
+        "mocha": "^11.7.1",
         "ts-node": "^10.9.2",
         "typescript": "^5.8.3"
     }

package/src/Firestore.ts

@@ -1,6 +1,6 @@
-import { FirestoreDocument } from '@stevenkellner/firebase-function';
+import { FirestoreCollection, FirestoreDocument } from '@stevenkellner/firebase-function';
 import { FirestoreScheme } from './FirestoreScheme';
-import { Fine, FineTemplate, UserInvitation, Person, User, Team } from './types';
+import { Fine, FineTemplate, Invitation, Person, User, Team } from './types';
 import { FirebaseConfiguration } from './firebase';
 
 export class Firestore {
@@ -31,33 +31,45 @@ export class Firestore {
             .document(id.value);
     }
 
-    public userInvitation(id: UserInvitation.Id): FirestoreDocument<UserInvitation> {
+    public invitation(id: Invitation.Id): FirestoreDocument<Invitation> {
         return this.base
-            .collection('userInvitations')
+            .collection('invitations')
             .document(id.value);
     }
 
-    public person(teamId: Team.Id, id: Person.Id): FirestoreDocument<Person> {
+    public persons(teamId: Team.Id): FirestoreCollection<{ [x: string]: FirestoreDocument<Person, never>; }> {
         return this.base
             .collection('teams')
             .document(teamId.guidString)
-            .collection('persons')
+            .collection('persons');
+    }
+
+    public person(teamId: Team.Id, id: Person.Id): FirestoreDocument<Person> {
+        return this.persons(teamId)
             .document(id.guidString);
     }
 
-    public fineTemplate(teamId: Team.Id, id: FineTemplate.Id): FirestoreDocument<FineTemplate> {
+    public fineTemplates(teamId: Team.Id): FirestoreCollection<{ [x: string]: FirestoreDocument<FineTemplate, never>; }> {
         return this.base
             .collection('teams')
             .document(teamId.guidString)
-            .collection('fineTemplates')
+            .collection('fineTemplates');
+    }
+
+    public fineTemplate(teamId: Team.Id, id: FineTemplate.Id): FirestoreDocument<FineTemplate> {
+        return this.fineTemplates(teamId)
             .document(id.guidString);
     }
 
-    public fine(teamId: Team.Id, id: Fine.Id): FirestoreDocument<Fine> {
+    public fines(teamId: Team.Id): FirestoreCollection<{ [x: string]: FirestoreDocument<Fine, never>; }> {
         return this.base
             .collection('teams')
             .document(teamId.guidString)
-            .collection('fines')
+            .collection('fines');
+    }
+
+    public fine(teamId: Team.Id, id: Fine.Id): FirestoreDocument<Fine> {
+        return this.fines(teamId)
             .document(id.guidString);
     }
 }

package/src/FirestoreScheme.ts

@@ -1,12 +1,12 @@
 import { FirestoreCollection, FirestoreDocument } from '@stevenkellner/firebase-function';
-import { Fine, FineTemplate, UserInvitation, Person, Team, User } from './types';
+import { Fine, FineTemplate, Invitation, Person, Team, User } from './types';
 
 export type FirestoreScheme = FirestoreDocument<never, {
     users: FirestoreCollection<{
         [UserId in string]: FirestoreDocument<User>
     }>
-    userInvitations: FirestoreCollection<{
-        [UserInvitationId in string]: FirestoreDocument<UserInvitation>
+    invitations: FirestoreCollection<{
+        [InvitationId in string]: FirestoreDocument<Invitation>
     }>
     teams: FirestoreCollection<{
         [TeamId in string]: FirestoreDocument<Team, {

package/src/firebaseFunctionsContext.ts

@@ -2,7 +2,7 @@ import { FirebaseFunctionsContext } from '@stevenkellner/firebase-function';
 import { TeamNewFunction,
     UserKickoutFunction, UserLoginFunction, UserRoleEditFunction,
     PaypalMeEditFunction, NotificationRegisterFunction, NotificationSubscribeFunction,
-    UserInvitationInviteFunction, UserInvitationRegisterFunction, UserInvitationWithdrawFunction,
+    InvitationInviteFunction, InvitationWithdrawFunction, InvitationGetInvitationFunction, InvitationRegisterFunction,
     PersonAddFunction, PersonDeleteFunction, PersonUpdateFunction,
     FineTemplateAddFunction, FineTemplateDeleteFunction, FineTemplateUpdateFunction,
     FineAddFunction, FineDeleteFunction, FineUpdateFunction
@@ -24,10 +24,11 @@ export const firebaseFunctionsContext = FirebaseFunctionsContext.build(builder =
         register: builder.function(NotificationRegisterFunction),
         subscribe: builder.function(NotificationSubscribeFunction)
     },
-    userInvitation: {
-        invite: builder.function(UserInvitationInviteFunction),
-        withdraw: builder.function(UserInvitationWithdrawFunction),
-        register: builder.function(UserInvitationRegisterFunction)
+    invitation: {
+        invite: builder.function(InvitationInviteFunction),
+        withdraw: builder.function(InvitationWithdrawFunction),
+        getInvitation: builder.function(InvitationGetInvitationFunction),
+        register: builder.function(InvitationRegisterFunction)
     },
     person: {
         add: builder.function(PersonAddFunction),

package/src/functions/index.ts

@@ -6,9 +6,10 @@ export * from './user/kickout';
 export * from './paypalMe/edit';
 export * from './notification/register';
 export * from './notification/subscribe';
-export * from './userInvitation/invite';
-export * from './userInvitation/withdraw';
-export * from './userInvitation/register';
+export * from './invitation/invite';
+export * from './invitation/withdraw';
+export * from './invitation/getInvitation';
+export * from './invitation/register';
 export * from './person/add';
 export * from './person/update';
 export * from './person/delete';

package/src/functions/invitation/getInvitation.ts

@@ -0,0 +1,138 @@
+import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
+import { Invitation, Person, PersonPrivateProperties, Team } from '../../types';
+import { Firestore } from '../../Firestore';
+import { compactMap, Flattable, ITypeBuilder } from '@stevenkellner/typescript-common-functionality';
+
+export class InvitationGetInvitationFunction extends FirebaseFunction<Invitation.Id, InvitationGetInvitationFunction.ReturnType> {
+
+    public parametersBuilder = Invitation.Id.builder;
+
+    public returnTypeBuilder = InvitationGetInvitationFunction.ReturnType.builder;
+
+    public async execute(invitationId: Invitation.Id): Promise<InvitationGetInvitationFunction.ReturnType> {
+
+        if (this.userId === null)
+            throw new FunctionsError('unauthenticated', 'User not authenticated');
+
+        const invitationSnapshot = await Firestore.shared.invitation(invitationId).snapshot();
+        if (!invitationSnapshot.exists)
+            throw new FunctionsError('not-found', 'Invitation not found');
+        const invitation = Invitation.builder.build(invitationSnapshot.data);
+
+        if (invitation.personId !== null)
+            return InvitationGetInvitationFunction.ReturnType.from(invitation.teamId, invitation.personId);
+
+        const personSnapshots = await Firestore.shared.persons(invitation.teamId).documentSnapshots();
+        const persons = compactMap(personSnapshots, personSnapshot => {
+            if (!personSnapshot.exists)
+                return null;
+            const person = Person.builder.build(personSnapshot.data);
+            return {
+                id: person.id,
+                properties: person.properties
+            };
+        });
+        return InvitationGetInvitationFunction.ReturnType.from(invitation.teamId, persons);
+    }
+}
+
+export namespace InvitationGetInvitationFunction {
+
+    export type PersonIdOrPersons = {
+        personId: Person.Id;
+    } | {
+        persons: {
+            id: Person.Id,
+            properties: PersonPrivateProperties,
+        }[];
+    };
+
+    export namespace PersonIdOrPersons {
+
+        export type Flatten = {
+            personId: Person.Id.Flatten,
+        } | {
+            persons: {
+                id: Person.Id.Flatten,
+                properties: PersonPrivateProperties.Flatten,
+            }[];
+        };
+    }
+
+    export class ReturnType implements Flattable<ReturnType.Flatten> {
+
+        private constructor(
+            public teamId: Team.Id,
+            private personIdOrPersons: PersonIdOrPersons
+        ) {}
+
+        public static from(teamId: Team.Id, personId: Person.Id): ReturnType;
+        public static from(teamId: Team.Id, persons: { id: Person.Id, properties: PersonPrivateProperties }[]): ReturnType;
+        public static from(teamId: Team.Id, personIdOrPersons: Person.Id | { id: Person.Id, properties: PersonPrivateProperties }[]): ReturnType {
+            if (Array.isArray(personIdOrPersons)) {
+                return new ReturnType(teamId, {
+                    persons: personIdOrPersons
+                });
+            }
+            return new ReturnType(teamId, {
+                personId: personIdOrPersons
+            });
+        }
+
+        public get personId(): Person.Id | null {
+            if (!('personId' in this.personIdOrPersons))
+                return null;
+            return this.personIdOrPersons.personId;
+        }
+
+        public get persons(): Person.Id[] | null {
+            if (!('persons' in this.personIdOrPersons))
+                return null;
+            return this.personIdOrPersons.persons.map(person => person.id);
+        }
+
+        public get flatten(): ReturnType.Flatten {
+            if ('personId' in this.personIdOrPersons) {
+                return {
+                    teamId: this.teamId.flatten,
+                    personId: this.personIdOrPersons.personId.flatten
+                };
+            }
+            return {
+                teamId: this.teamId.flatten,
+                persons: this.personIdOrPersons.persons.map(person => ({
+                    id: person.id.flatten,
+                    properties: person.properties.flatten
+                }))
+            }
+        }
+    }
+
+    export namespace ReturnType {
+
+        export type Flatten = {
+            teamId: Team.Id.Flatten
+        } & InvitationGetInvitationFunction.PersonIdOrPersons.Flatten;
+
+        export class TypeBuilder implements ITypeBuilder<Flatten, ReturnType> {
+
+            public build(value: Flatten): ReturnType {
+                if ('personId' in value) {
+                    return ReturnType.from(
+                        Team.Id.builder.build(value.teamId),
+                        Person.Id.builder.build(value.personId)
+                    );
+                }
+                return ReturnType.from(
+                    Team.Id.builder.build(value.teamId),
+                    value.persons.map(person => ({
+                        id: Person.Id.builder.build(person.id),
+                        properties: PersonPrivateProperties.builder.build(person.properties)
+                    }))
+                );
+            }
+        }
+
+        export const builder = new TypeBuilder();
+    }
+}

package/src/functions/invitation/invite.ts

@@ -0,0 +1,32 @@
+import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
+import { Invitation } from '../../types';
+import { checkAuthentication } from '../../checkAuthentication';
+import { Firestore } from '../../Firestore';
+
+export class InvitationInviteFunction extends FirebaseFunction<Invitation, Invitation.Id> {
+
+    public parametersBuilder = Invitation.builder;
+
+    public returnTypeBuilder = Invitation.Id.builder;
+
+    public async execute(invitation: Invitation): Promise<Invitation.Id> {
+
+        await checkAuthentication(this.userId, invitation.teamId, 'team-manager');
+
+        if (invitation.personId !== null) {
+
+            const personSnapshot = await Firestore.shared.person(invitation.teamId, invitation.personId).snapshot();
+            if (!personSnapshot.exists)
+                throw new FunctionsError('not-found', 'Person not found');
+
+            if (personSnapshot.data.signInProperties !== null)
+                throw new FunctionsError('already-exists', 'Person already has an account');
+
+        }
+
+        const invitationId = invitation.createId();
+        await Firestore.shared.invitation(invitationId).set(invitation);
+
+        return invitationId;
+    }
+}

package/src/functions/invitation/register.ts

@@ -0,0 +1,69 @@
+import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
+import { Person, PersonSignInProperties, Team, User, Invitation } from '../../types';
+import { Firestore } from '../../Firestore';
+import { Flattable, ObjectTypeBuilder, UtcDate } from '@stevenkellner/typescript-common-functionality';
+
+export namespace InvitationRegisterFunction {
+
+    export type Parameters = {
+        teamId: Team.Id
+        personId: Person.Id
+    };
+}
+
+export class InvitationRegisterFunction extends FirebaseFunction<InvitationRegisterFunction.Parameters, User> {
+
+    public parametersBuilder =  new ObjectTypeBuilder<Flattable.Flatten<InvitationRegisterFunction.Parameters>, InvitationRegisterFunction.Parameters>({
+        teamId: Team.Id.builder,
+        personId: Person.Id.builder
+    });
+
+    public returnTypeBuilder = User.builder;
+
+    public async execute(parameters: InvitationRegisterFunction.Parameters): Promise<User> {
+
+        if (this.userId === null)
+            throw new FunctionsError('unauthenticated', 'User not authenticated');
+        const userId = User.Id.builder.build(this.userId);
+        const user = await this.getUser(userId);
+
+        if (user.teams.has(parameters.teamId))
+            throw new FunctionsError('already-exists', 'User already in team');
+
+        const teamSnapshot = await Firestore.shared.team(parameters.teamId).snapshot();
+        if (!teamSnapshot.exists)
+            throw new FunctionsError('not-found', 'Team not found');
+        const team = Team.builder.build(teamSnapshot.data);
+
+        const personSnapshot = await Firestore.shared.person(parameters.teamId, parameters.personId).snapshot();
+        if (!personSnapshot.exists)
+            throw new FunctionsError('not-found', 'Person not found');
+        const person = Person.builder.build(personSnapshot.data);
+
+        if (person.signInProperties !== null)
+            throw new FunctionsError('already-exists', 'Person already registered');
+
+        await this.removeUserInvitation(parameters.teamId, parameters.personId);
+
+        user.teams.set(parameters.teamId, new User.TeamProperties(team.name, parameters.personId));
+        await Firestore.shared.user(userId).set(user);
+
+        person.signInProperties = new PersonSignInProperties(userId, UtcDate.now);
+        await Firestore.shared.person(parameters.teamId, parameters.personId).set(person);
+
+        return user;
+    }
+
+    private async getUser(userId: User.Id): Promise<User> {
+        const userSnapshot = await Firestore.shared.user(userId).snapshot();
+        if (userSnapshot.exists)
+            return User.builder.build(userSnapshot.data);
+        return new User(userId);
+    }
+
+    private async removeUserInvitation(teamId: Team.Id, personId: Person.Id) {
+        const invitation = new Invitation(teamId, personId);
+        const invitationId = invitation.createId();
+        await Firestore.shared.invitation(invitationId).remove();
+    }
+}

package/src/functions/{userInvitation → invitation}/withdraw.ts

@@ -1,24 +1,24 @@
 import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
-import { UserInvitation } from '../../types';
+import { Invitation } from '../../types';
 import { checkAuthentication } from '../../checkAuthentication';
 import { Firestore } from '../../Firestore';
 import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export class UserInvitationWithdrawFunction extends FirebaseFunction<UserInvitation, void> {
+export class InvitationWithdrawFunction extends FirebaseFunction<Invitation, void> {
 
-    public parametersBuilder = UserInvitation.builder;
+    public parametersBuilder = Invitation.builder;
 
     public returnTypeBuilder = new ValueTypeBuilder<void>();
 
-    public async execute(invitation: UserInvitation): Promise<void> {
+    public async execute(invitation: Invitation): Promise<void> {
 
         await checkAuthentication(this.userId, invitation.teamId, 'team-manager');
 
         const invitationId = invitation.createId();
-        const invitationSnapshot = await Firestore.shared.userInvitation(invitationId).snapshot();
+        const invitationSnapshot = await Firestore.shared.invitation(invitationId).snapshot();
         if (!invitationSnapshot.exists)
             throw new FunctionsError('not-found', 'Invitation not found');
 
-        await Firestore.shared.userInvitation(invitationId).remove();
+        await Firestore.shared.invitation(invitationId).remove();
     }
 }

package/src/functions/user/kickout.ts

@@ -1,5 +1,5 @@
 import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
-import { Team, User } from '../../types';
+import { Person, Team, User } from '../../types';
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 import { Firestore } from '../../Firestore';
 import { checkAuthentication } from '../../checkAuthentication';
@@ -37,6 +37,15 @@ export class UserKickoutFunction extends FirebaseFunction<UserKickoutFunction.Pa
         if (userTeamProperties === null)
             throw new FunctionsError('not-found', 'User is not a member of the team.');
 
-        await Firestore.shared.person(parameters.teamId, userTeamProperties.personId).remove();
+        const personSnapshot = await Firestore.shared.person(parameters.teamId, userTeamProperties.personId).snapshot();
+        if (!personSnapshot.exists)
+            throw new FunctionsError('not-found', 'Person not found.');
+        const person = Person.builder.build(personSnapshot.data);
+
+        person.signInProperties = null;
+        await Firestore.shared.person(parameters.teamId, userTeamProperties.personId).set(person);
+
+        user.teams.delete(parameters.teamId);
+        await Firestore.shared.user(parameters.userId).set(user);
     }
 }

package/src/types/Invitation.ts

@@ -0,0 +1,60 @@
+import { BytesCoder, Flattable, ITypeBuilder, OptionalTypeBuilder, Sha512, Tagged, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+import { Team } from './Team';
+import { Person } from './Person';
+
+export class Invitation implements Flattable<Invitation.Flatten> {
+
+    constructor(
+        public teamId: Team.Id,
+        public personId: Person.Id | null
+    ) {}
+
+    public createId(): Invitation.Id {
+        const hasher = new Sha512();
+        const teamIdBytes = BytesCoder.fromUtf8(this.teamId.guidString);
+        let invitationBytes = teamIdBytes;
+        if (this.personId !== null) {
+            const personIdBytes = BytesCoder.fromUtf8(this.personId.guidString);
+            invitationBytes = new Uint8Array([...teamIdBytes, ...personIdBytes]);
+        }
+        const hashedInvitationBytes = hasher.hash(invitationBytes);
+        const rawId = BytesCoder.toHex(hashedInvitationBytes).slice(0, 12);
+        return new Tagged(rawId, 'invitation');
+    }
+
+    public get flatten(): Invitation.Flatten {
+        return {
+            teamId: this.teamId.flatten,
+            personId: this.personId !== null ? this.personId.flatten : null
+        };
+    }
+}
+
+export namespace Invitation {
+
+    export type Id = Tagged<string, 'invitation'>;
+
+    export namespace Id {
+
+        export type Flatten = string;
+
+        export const builder = Tagged.builder('invitation' as const, new ValueTypeBuilder<string>());
+    }
+
+    export type Flatten = {
+        teamId: Team.Id.Flatten,
+        personId: Person.Id.Flatten | null
+    };
+
+    export class TypeBuilder implements ITypeBuilder<Flatten, Invitation> {
+
+        public build(value: Flatten): Invitation {
+            return new Invitation(
+                Team.Id.builder.build(value.teamId),
+                new OptionalTypeBuilder(Person.Id.builder).build(value.personId)
+            );
+        }
+    }
+
+    export const builder = new TypeBuilder();
+}

package/src/types/index.ts

@@ -3,7 +3,7 @@ export * from './Fine';
 export * from './FineAmount';
 export * from './FineTemplate';
 export * from './FineTemplateRepetition';
-export * from './UserInvitation';
+export * from './Invitation';
 export * from './Localization';
 export * from './MoneyAmount';
 export * from './NotificationProperties';

package/lib/src/functions/userInvitation/invite.d.ts

@@ -1,7 +0,0 @@
-import { FirebaseFunction } from '@stevenkellner/firebase-function';
-import { UserInvitation } from '../../types';
-export declare class UserInvitationInviteFunction extends FirebaseFunction<UserInvitation, UserInvitation.Id> {
-    parametersBuilder: UserInvitation.TypeBuilder;
-    returnTypeBuilder: import("@stevenkellner/typescript-common-functionality").Tagged.TypeBuilder<string, "userInvitation">;
-    execute(invitation: UserInvitation): Promise<UserInvitation.Id>;
-}

package/lib/src/functions/userInvitation/invite.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserInvitationInviteFunction = void 0;
-const firebase_function_1 = require("@stevenkellner/firebase-function");
-const types_1 = require("../../types");
-const checkAuthentication_1 = require("../../checkAuthentication");
-const Firestore_1 = require("../../Firestore");
-class UserInvitationInviteFunction extends firebase_function_1.FirebaseFunction {
-    parametersBuilder = types_1.UserInvitation.builder;
-    returnTypeBuilder = types_1.UserInvitation.Id.builder;
-    async execute(invitation) {
-        await (0, checkAuthentication_1.checkAuthentication)(this.userId, invitation.teamId, 'team-manager');
-        const personSnapshot = await Firestore_1.Firestore.shared.person(invitation.teamId, invitation.personId).snapshot();
-        if (!personSnapshot.exists)
-            throw new firebase_function_1.FunctionsError('not-found', 'Person not found');
-        if (personSnapshot.data.signInProperties !== null)
-            throw new firebase_function_1.FunctionsError('already-exists', 'Person already has an account');
-        const invitationId = invitation.createId();
-        await Firestore_1.Firestore.shared.userInvitation(invitationId).set(invitation);
-        return invitationId;
-    }
-}
-exports.UserInvitationInviteFunction = UserInvitationInviteFunction;

package/lib/src/functions/userInvitation/register.d.ts

@@ -1,7 +0,0 @@
-import { FirebaseFunction } from '@stevenkellner/firebase-function';
-import { UserInvitation, User } from '../../types';
-export declare class UserInvitationRegisterFunction extends FirebaseFunction<UserInvitation.Id, User> {
-    parametersBuilder: import("@stevenkellner/typescript-common-functionality").Tagged.TypeBuilder<string, "userInvitation">;
-    returnTypeBuilder: User.TypeBuilder;
-    execute(invitationId: UserInvitation.Id): Promise<User>;
-}

package/lib/src/functions/userInvitation/withdraw.d.ts

@@ -1,8 +0,0 @@
-import { FirebaseFunction } from '@stevenkellner/firebase-function';
-import { UserInvitation } from '../../types';
-import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-export declare class UserInvitationWithdrawFunction extends FirebaseFunction<UserInvitation, void> {
-    parametersBuilder: UserInvitation.TypeBuilder;
-    returnTypeBuilder: ValueTypeBuilder<void>;
-    execute(invitation: UserInvitation): Promise<void>;
-}

package/lib/src/types/UserInvitation.d.ts

@@ -1,25 +0,0 @@
-import { Flattable, ITypeBuilder, Tagged } from '@stevenkellner/typescript-common-functionality';
-import { Team } from './Team';
-import { Person } from './Person';
-export declare class UserInvitation implements Flattable<UserInvitation.Flatten> {
-    teamId: Team.Id;
-    personId: Person.Id;
-    constructor(teamId: Team.Id, personId: Person.Id);
-    createId(): UserInvitation.Id;
-    get flatten(): UserInvitation.Flatten;
-}
-export declare namespace UserInvitation {
-    type Id = Tagged<string, 'userInvitation'>;
-    namespace Id {
-        type Flatten = string;
-        const builder: Tagged.TypeBuilder<string, "userInvitation">;
-    }
-    type Flatten = {
-        teamId: Team.Id.Flatten;
-        personId: Person.Id.Flatten;
-    };
-    class TypeBuilder implements ITypeBuilder<Flatten, UserInvitation> {
-        build(value: Flatten): UserInvitation;
-    }
-    const builder: TypeBuilder;
-}

package/lib/src/types/UserInvitation.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserInvitation = void 0;
-const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
-const Team_1 = require("./Team");
-const Person_1 = require("./Person");
-class UserInvitation {
-    teamId;
-    personId;
-    constructor(teamId, personId) {
-        this.teamId = teamId;
-        this.personId = personId;
-    }
-    createId() {
-        const hasher = new typescript_common_functionality_1.Sha512();
-        const teamIdBytes = typescript_common_functionality_1.BytesCoder.fromUtf8(this.teamId.guidString);
-        const personIdBytes = typescript_common_functionality_1.BytesCoder.fromUtf8(this.personId.guidString);
-        const hashedInvitationBytes = hasher.hash(new Uint8Array([...teamIdBytes, ...personIdBytes]));
-        const rawId = typescript_common_functionality_1.BytesCoder.toHex(hashedInvitationBytes).slice(0, 12);
-        return new typescript_common_functionality_1.Tagged(rawId, 'userInvitation');
-    }
-    get flatten() {
-        return {
-            teamId: this.teamId.flatten,
-            personId: this.personId.flatten
-        };
-    }
-}
-exports.UserInvitation = UserInvitation;
-(function (UserInvitation) {
-    let Id;
-    (function (Id) {
-        Id.builder = typescript_common_functionality_1.Tagged.builder('userInvitation', new typescript_common_functionality_1.ValueTypeBuilder());
-    })(Id = UserInvitation.Id || (UserInvitation.Id = {}));
-    class TypeBuilder {
-        build(value) {
-            return new UserInvitation(Team_1.Team.Id.builder.build(value.teamId), Person_1.Person.Id.builder.build(value.personId));
-        }
-    }
-    UserInvitation.TypeBuilder = TypeBuilder;
-    UserInvitation.builder = new TypeBuilder();
-})(UserInvitation || (exports.UserInvitation = UserInvitation = {}));