@stevenkellner/team-conduct-api 2.0.2 → 2.0.3

package/src/functions/fine/update.ts

@@ -3,16 +3,19 @@ import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Fine, Person, Team } from '../../types';
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export type FineUpdateFunctionParameters = {
-    teamId: Team.Id,
-    personId: Person.Id,
-    fine: Fine,
-    configuration: Configuration
-};
+export namespace FineUpdateFunction {
 
-export abstract class FineUpdateFunctionBase extends FirebaseFunction<FineUpdateFunctionParameters, void> {
+    export type Parameters = {
+        teamId: Team.Id,
+        personId: Person.Id,
+        fine: Fine,
+        configuration: Configuration
+    };
+}
+
+export class FineUpdateFunction implements FirebaseFunction<FineUpdateFunction.Parameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<FineUpdateFunctionParameters>, FineUpdateFunctionParameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<FineUpdateFunction.Parameters>, FineUpdateFunction.Parameters>({
         teamId: Team.Id.builder,
         personId: Person.Id.builder,
         fine: Fine.builder,

package/src/functions/fineTemplate/add.ts

@@ -2,14 +2,17 @@ import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { FineTemplate, Team } from '../../types';
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export type FineTemplateAddFunctionParameters = {
-    teamId: Team.Id,
-    fineTemplate: FineTemplate
-};
+export namespace FineTemplateAddFunction {
 
-export abstract class FineTemplateAddFunctionBase extends FirebaseFunction<FineTemplateAddFunctionParameters, void> {
+    export type Parameters = {
+        teamId: Team.Id,
+        fineTemplate: FineTemplate
+    };
+}
+
+export class FineTemplateAddFunction implements FirebaseFunction<FineTemplateAddFunction.Parameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<FineTemplateAddFunctionParameters>, FineTemplateAddFunctionParameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<FineTemplateAddFunction.Parameters>, FineTemplateAddFunction.Parameters>({
         teamId: Team.Id.builder,
         fineTemplate: FineTemplate.builder
     });

package/src/functions/fineTemplate/delete.ts

@@ -2,14 +2,17 @@ import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { FineTemplate, Team } from '../../types';
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export type FineTemplateDeleteFunctionParameters = {
-    teamId: Team.Id,
-    id: FineTemplate.Id
-};
+export namespace FineTemplateDeleteFunction {
 
-export abstract class FineTemplateDeleteFunctionBase extends FirebaseFunction<FineTemplateDeleteFunctionParameters, void> {
+    export type Parameters = {
+        teamId: Team.Id,
+        id: FineTemplate.Id
+    };
+}
+
+export class FineTemplateDeleteFunction implements FirebaseFunction<FineTemplateDeleteFunction.Parameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<FineTemplateDeleteFunctionParameters>, FineTemplateDeleteFunctionParameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<FineTemplateDeleteFunction.Parameters>, FineTemplateDeleteFunction.Parameters>({
         teamId: Team.Id.builder,
         id: FineTemplate.Id.builder
     });

package/src/functions/fineTemplate/update.ts

@@ -2,13 +2,17 @@ import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { FineTemplate, Team } from '../../types';
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export type FineTemplateUpdateFunctionParameters = {
-    teamId: Team.Id,
-    fineTemplate: FineTemplate
+export namespace FineTemplateUpdateFunction {
+
+    export type Parameters = {
+        teamId: Team.Id,
+        fineTemplate: FineTemplate
 };
-export abstract class FineTemplateUpdateFunctionBase extends FirebaseFunction<FineTemplateUpdateFunctionParameters, void> {
+}
+
+export class FineTemplateUpdateFunction implements FirebaseFunction<FineTemplateUpdateFunction.Parameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<FineTemplateUpdateFunctionParameters>, FineTemplateUpdateFunctionParameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<FineTemplateUpdateFunction.Parameters>, FineTemplateUpdateFunction.Parameters>({
         teamId: Team.Id.builder,
         fineTemplate: FineTemplate.builder
     });

package/src/functions/firebaseFunctionsContext.ts

@@ -0,0 +1,48 @@
+import { FirebaseFunctionsContext } from '@stevenkellner/firebase-function';
+import { TeamNewFunction,
+    UserKickoutFunction, UserLoginFunction, UserRoleEditFunction,
+    PaypalMeEditFunction, NotificationRegisterFunction, NotificationSubscribeFunction,
+    InvitationInviteFunction, InvitationWithdrawFunction, InvitationGetInvitationFunction, InvitationRegisterFunction,
+    PersonAddFunction, PersonDeleteFunction, PersonUpdateFunction,
+    FineTemplateAddFunction, FineTemplateDeleteFunction, FineTemplateUpdateFunction,
+    FineAddFunction, FineDeleteFunction, FineUpdateFunction
+} from '.';
+
+export const firebaseFunctionsContext = FirebaseFunctionsContext.build(builder => ({
+    team: {
+        new: builder.function(TeamNewFunction)
+    },
+    user: {
+        kickout: builder.function(UserKickoutFunction),
+        login: builder.function(UserLoginFunction),
+        roleEdit: builder.function(UserRoleEditFunction)
+    },
+    paypalMe: {
+        edit: builder.function(PaypalMeEditFunction)
+    },
+    notification: {
+        register: builder.function(NotificationRegisterFunction),
+        subscribe: builder.function(NotificationSubscribeFunction)
+    },
+    invitation: {
+        invite: builder.function(InvitationInviteFunction),
+        withdraw: builder.function(InvitationWithdrawFunction),
+        getInvitation: builder.function(InvitationGetInvitationFunction),
+        register: builder.function(InvitationRegisterFunction)
+    },
+    person: {
+        add: builder.function(PersonAddFunction),
+        update: builder.function(PersonUpdateFunction),
+        delete: builder.function(PersonDeleteFunction)
+    },
+    fineTemplate: {
+        add: builder.function(FineTemplateAddFunction),
+        update: builder.function(FineTemplateUpdateFunction),
+        delete: builder.function(FineTemplateDeleteFunction)
+    },
+    fine: {
+        add: builder.function(FineAddFunction),
+        update: builder.function(FineUpdateFunction),
+        delete: builder.function(FineDeleteFunction)
+    }
+}));

package/src/functions/index.ts

@@ -18,3 +18,4 @@ export * from './fine/delete';
 export * from './fineTemplate/add';
 export * from './fineTemplate/update';
 export * from './fineTemplate/delete';
+export * from './firebaseFunctionsContext'

package/src/functions/invitation/getInvitation.ts

@@ -2,116 +2,119 @@ import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Invitation, Person, PersonPrivateProperties, Team } from '../../types';
 import {  Flattable, ITypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export abstract class InvitationGetInvitationFunctionBase extends FirebaseFunction<Invitation.Id, InvitationGetInvitationFunctionReturnType> {
+export class InvitationGetInvitationFunction implements FirebaseFunction<Invitation.Id, InvitationGetInvitationFunction.ReturnType> {
 
     public parametersBuilder = Invitation.Id.builder;
 
-    public returnTypeBuilder = InvitationGetInvitationFunctionReturnType.builder;
+    public returnTypeBuilder = InvitationGetInvitationFunction.ReturnType.builder;
 }
 
-export type PersonIdOrPersons = {
-    personId: Person.Id;
-} | {
-    persons: {
-        id: Person.Id,
-        properties: PersonPrivateProperties,
-    }[];
-};
+export namespace InvitationGetInvitationFunction {
 
-export namespace PersonIdOrPersons {
-
-    export type Flatten = {
-        personId: Person.Id.Flatten,
+    export type PersonIdOrPersons = {
+        personId: Person.Id;
     } | {
         persons: {
-            id: Person.Id.Flatten,
-            properties: PersonPrivateProperties.Flatten,
+            id: Person.Id,
+            properties: PersonPrivateProperties,
         }[];
     };
-}
 
-export class InvitationGetInvitationFunctionReturnType implements Flattable<InvitationGetInvitationFunctionReturnType.Flatten> {
+    export namespace PersonIdOrPersons {
 
-    private constructor(
-        public teamId: Team.Id,
-        public teamName: string,
-        private personIdOrPersons: PersonIdOrPersons
-    ) {}
+        export type Flatten = {
+            personId: Person.Id.Flatten,
+        } | {
+            persons: {
+                id: Person.Id.Flatten,
+                properties: PersonPrivateProperties.Flatten,
+            }[];
+        };
+    }
 
-    public static from(teamId: Team.Id, teamName: string, personId: Person.Id): InvitationGetInvitationFunctionReturnType;
-    public static from(teamId: Team.Id, teamName: string, persons: { id: Person.Id, properties: PersonPrivateProperties }[]): InvitationGetInvitationFunctionReturnType;
-    public static from(teamId: Team.Id, teamName: string, personIdOrPersons: Person.Id | { id: Person.Id, properties: PersonPrivateProperties }[]): InvitationGetInvitationFunctionReturnType {
-        if (Array.isArray(personIdOrPersons)) {
-            return new InvitationGetInvitationFunctionReturnType(teamId, teamName, {
-                persons: personIdOrPersons
+    export class ReturnType implements Flattable<ReturnType.Flatten> {
+
+        private constructor(
+            public teamId: Team.Id,
+            public teamName: string,
+            private personIdOrPersons: PersonIdOrPersons
+        ) {}
+
+        public static from(teamId: Team.Id, teamName: string, personId: Person.Id): ReturnType;
+        public static from(teamId: Team.Id, teamName: string, persons: { id: Person.Id, properties: PersonPrivateProperties }[]): ReturnType;
+        public static from(teamId: Team.Id, teamName: string, personIdOrPersons: Person.Id | { id: Person.Id, properties: PersonPrivateProperties }[]): ReturnType {
+            if (Array.isArray(personIdOrPersons)) {
+                return new ReturnType(teamId, teamName, {
+                    persons: personIdOrPersons
+                });
+            }
+            return new ReturnType(teamId, teamName, {
+                personId: personIdOrPersons
             });
         }
-        return new InvitationGetInvitationFunctionReturnType(teamId, teamName, {
-            personId: personIdOrPersons
-        });
-    }
 
-    public get personId(): Person.Id | null {
-        if (!('personId' in this.personIdOrPersons))
-            return null;
-        return this.personIdOrPersons.personId;
-    }
+        public get personId(): Person.Id | null {
+            if (!('personId' in this.personIdOrPersons))
+                return null;
+            return this.personIdOrPersons.personId;
+        }
 
-    public get persons(): {
-            id: Person.Id,
-            properties: PersonPrivateProperties,
-        }[] | null {
-        if (!('persons' in this.personIdOrPersons))
-            return null;
-        return this.personIdOrPersons.persons;
-    }
+        public get persons(): {
+                id: Person.Id,
+                properties: PersonPrivateProperties,
+            }[] | null {
+            if (!('persons' in this.personIdOrPersons))
+                return null;
+            return this.personIdOrPersons.persons;
+        }
 
-    public get flatten(): InvitationGetInvitationFunctionReturnType.Flatten {
-        if ('personId' in this.personIdOrPersons) {
+        public get flatten(): ReturnType.Flatten {
+            if ('personId' in this.personIdOrPersons) {
+                return {
+                    teamId: this.teamId.flatten,
+                    teamName: this.teamName,
+                    personId: this.personIdOrPersons.personId.flatten
+                };
+            }
             return {
                 teamId: this.teamId.flatten,
                 teamName: this.teamName,
-                personId: this.personIdOrPersons.personId.flatten
-            };
-        }
-        return {
-            teamId: this.teamId.flatten,
-            teamName: this.teamName,
-            persons: this.personIdOrPersons.persons.map(person => ({
-                id: person.id.flatten,
-                properties: person.properties.flatten
-            }))
+                persons: this.personIdOrPersons.persons.map(person => ({
+                    id: person.id.flatten,
+                    properties: person.properties.flatten
+                }))
+            }
         }
     }
-}
 
-export namespace InvitationGetInvitationFunctionReturnType {
+    export namespace ReturnType {
 
-    export type Flatten = {
-        teamId: Team.Id.Flatten,
-        teamName: string
-    } & PersonIdOrPersons.Flatten;
+        export type Flatten = {
+            teamId: Team.Id.Flatten,
+            teamName: string
+        } & PersonIdOrPersons.Flatten;
 
-    export class TypeBuilder implements ITypeBuilder<Flatten, InvitationGetInvitationFunctionReturnType> {
+        export class TypeBuilder implements ITypeBuilder<Flatten, ReturnType> {
 
-        public build(value: Flatten): InvitationGetInvitationFunctionReturnType {
-            if ('personId' in value) {
-                return InvitationGetInvitationFunctionReturnType.from(
+            public build(value: Flatten): ReturnType {
+                if ('personId' in value) {
+                    return ReturnType.from(
+                        Team.Id.builder.build(value.teamId),
+                        value.teamName,
+                        Person.Id.builder.build(value.personId)
+                    );
+                }
+                return ReturnType.from(
                     Team.Id.builder.build(value.teamId),
                     value.teamName,
-                    Person.Id.builder.build(value.personId)
+                    value.persons.map(person => ({
+                        id: Person.Id.builder.build(person.id),
+                        properties: PersonPrivateProperties.builder.build(person.properties)
+                    }))
                 );
             }
-            return InvitationGetInvitationFunctionReturnType.from(
-                Team.Id.builder.build(value.teamId),
-                value.teamName,
-                value.persons.map(person => ({
-                    id: Person.Id.builder.build(person.id),
-                    properties: PersonPrivateProperties.builder.build(person.properties)
-                }))
-            );
         }
-    }
 
-    export const builder = new TypeBuilder();
+        export const builder = new TypeBuilder();
+    }
 }

package/src/functions/invitation/invite.ts

@@ -1,7 +1,7 @@
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Invitation } from '../../types';
 
-export abstract class InvitationInviteFunctionBase extends FirebaseFunction<Invitation, Invitation.Id> {
+export class InvitationInviteFunction implements FirebaseFunction<Invitation, Invitation.Id> {
 
     public parametersBuilder = Invitation.builder;
 

package/src/functions/invitation/register.ts

@@ -2,14 +2,17 @@ import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Person, Team, User } from '../../types';
 import { Flattable, ObjectTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export type InvitationRegisterFunctionParameters = {
-    teamId: Team.Id
-    personId: Person.Id
-};
+export namespace InvitationRegisterFunction {
 
-export abstract class InvitationRegisterFunctionBase extends FirebaseFunction<InvitationRegisterFunctionParameters, User> {
+    export type Parameters = {
+        teamId: Team.Id
+        personId: Person.Id
+    };
+}
+
+export class InvitationRegisterFunction implements FirebaseFunction<InvitationRegisterFunction.Parameters, User> {
 
-    public parametersBuilder =  new ObjectTypeBuilder<Flattable.Flatten<InvitationRegisterFunctionParameters>, InvitationRegisterFunctionParameters>({
+    public parametersBuilder =  new ObjectTypeBuilder<Flattable.Flatten<InvitationRegisterFunction.Parameters>, InvitationRegisterFunction.Parameters>({
         teamId: Team.Id.builder,
         personId: Person.Id.builder
     });

package/src/functions/invitation/withdraw.ts

@@ -2,7 +2,7 @@ import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Invitation } from '../../types';
 import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export abstract class InvitationWithdrawFunctionBase extends FirebaseFunction<Invitation, void> {
+export class InvitationWithdrawFunction implements FirebaseFunction<Invitation, void> {
 
     public parametersBuilder = Invitation.builder;
 

package/src/functions/notification/register.ts

@@ -2,15 +2,18 @@ import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Person, Team } from '../../types';
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export type NotificationRegisterFunctionParameters = {
-    teamId: Team.Id,
-    personId: Person.Id,
-    token: string
+export namespace NotificationRegisterFunction {
+
+    export type Parameters = {
+        teamId: Team.Id,
+        personId: Person.Id,
+        token: string
+    };
 }
 
-export abstract class NotificationRegisterFunctionBase extends FirebaseFunction<NotificationRegisterFunctionParameters, void> {
+export class NotificationRegisterFunction implements FirebaseFunction<NotificationRegisterFunction.Parameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<NotificationRegisterFunctionParameters>, NotificationRegisterFunctionParameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<NotificationRegisterFunction.Parameters>, NotificationRegisterFunction.Parameters>({
         teamId: Team.Id.builder,
         personId: Person.Id.builder,
         token: new ValueTypeBuilder()

package/src/functions/notification/subscribe.ts

@@ -2,15 +2,18 @@ import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { NotificationProperties, Person, Team } from '../../types';
 import { ArrayTypeBuilder, Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export type NotificationSubscribeFunctionParameters = {
-    teamId: Team.Id,
-    personId: Person.Id,
-    subscriptions: NotificationProperties.Subscription[]
-};
+export namespace NotificationSubscribeFunction {
 
-export abstract class NotificationSubscribeFunctionBase extends FirebaseFunction<NotificationSubscribeFunctionParameters, void> {
+    export type Parameters = {
+        teamId: Team.Id,
+        personId: Person.Id,
+        subscriptions: NotificationProperties.Subscription[]
+    };
+}
+
+export class NotificationSubscribeFunction implements FirebaseFunction<NotificationSubscribeFunction.Parameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<NotificationSubscribeFunctionParameters>, NotificationSubscribeFunctionParameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<NotificationSubscribeFunction.Parameters>, NotificationSubscribeFunction.Parameters>({
         teamId: Team.Id.builder,
         personId: Person.Id.builder,
         subscriptions: new ArrayTypeBuilder(new ValueTypeBuilder())

package/src/functions/paypalMe/edit.ts

@@ -2,14 +2,17 @@ import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/t
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Team } from '../../types';
 
-export type PaypalMeEditFunctionParameters = {
-    teamId: Team.Id;
-    paypalMeLink: string | null;
-};
+export namespace PaypalMeEditFunction {
 
-export abstract class PaypalMeEditFunctionBase extends FirebaseFunction<PaypalMeEditFunctionParameters, void> {
+    export type Parameters = {
+        teamId: Team.Id;
+        paypalMeLink: string | null;
+    };
+}
+
+export class PaypalMeEditFunction implements FirebaseFunction<PaypalMeEditFunction.Parameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PaypalMeEditFunctionParameters>, PaypalMeEditFunctionParameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PaypalMeEditFunction.Parameters>, PaypalMeEditFunction.Parameters>({
         teamId: Team.Id.builder,
         paypalMeLink: new ValueTypeBuilder()
     });

package/src/functions/person/add.ts

@@ -2,15 +2,18 @@ import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Person, PersonPrivateProperties, Team } from '../../types';
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export type PersonAddFunctionParameters = {
-    teamId: Team.Id
-    id: Person.Id,
-    properties: PersonPrivateProperties
-};
+export namespace PersonAddFunction {
 
-export abstract class PersonAddFunctionBase extends FirebaseFunction<PersonAddFunctionParameters, void> {
+    export type Parameters = {
+        teamId: Team.Id
+        id: Person.Id,
+        properties: PersonPrivateProperties
+    };
+}
+
+export class PersonAddFunction implements FirebaseFunction<PersonAddFunction.Parameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PersonAddFunctionParameters>, PersonAddFunctionParameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PersonAddFunction.Parameters>, PersonAddFunction.Parameters>({
         teamId: Team.Id.builder,
         id: Person.Id.builder,
         properties: PersonPrivateProperties.builder

package/src/functions/person/delete.ts

@@ -2,14 +2,17 @@ import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Person, Team } from '../../types';
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export type PersonDeleteFunctionParameters = {
-    teamId: Team.Id,
-    id: Person.Id
+export namespace PersonDeleteFunction {
+
+    export type Parameters = {
+        teamId: Team.Id,
+        id: Person.Id
+    };
 }
 
-export abstract class PersonDeleteFunctionBase extends FirebaseFunction<PersonDeleteFunctionParameters, void> {
+export class PersonDeleteFunction implements FirebaseFunction<PersonDeleteFunction.Parameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PersonDeleteFunctionParameters>, PersonDeleteFunctionParameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PersonDeleteFunction.Parameters>, PersonDeleteFunction.Parameters>({
         teamId: Team.Id.builder,
         id: Person.Id.builder
     });

package/src/functions/person/update.ts

@@ -2,15 +2,18 @@ import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Person, PersonPrivateProperties, Team } from '../../types';
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export type PersonUpdateFunctionParameters = {
-    teamId: Team.Id,
-    id: Person.Id,
-    properties: PersonPrivateProperties
-};
+export namespace PersonUpdateFunction {
 
-export abstract class PersonUpdateFunctionBase extends FirebaseFunction<PersonUpdateFunctionParameters, void> {
+    export type Parameters = {
+        teamId: Team.Id,
+        id: Person.Id,
+        properties: PersonPrivateProperties
+    };
+}
+
+export class PersonUpdateFunction implements FirebaseFunction<PersonUpdateFunction.Parameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PersonUpdateFunctionParameters>, PersonUpdateFunctionParameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<PersonUpdateFunction.Parameters>, PersonUpdateFunction.Parameters>({
         teamId: Team.Id.builder,
         id: Person.Id.builder,
         properties: PersonPrivateProperties.builder

package/src/functions/team/new.ts

@@ -2,17 +2,20 @@ import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/t
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Person, PersonPrivateProperties, User, Team } from '../../types';
 
-export type TeamNewFunctionParameters = {
-    id: Team.Id
-    name: string
-    paypalMeLink: string | null
-    personId: Person.Id
-    personProperties: PersonPrivateProperties
-};
+export namespace TeamNewFunction {
 
-export abstract class TeamNewFunctionBase extends FirebaseFunction<TeamNewFunctionParameters, User> {
+    export type Parameters = {
+        id: Team.Id
+        name: string
+        paypalMeLink: string | null
+        personId: Person.Id
+        personProperties: PersonPrivateProperties
+    };
+}
+
+export class TeamNewFunction implements FirebaseFunction<TeamNewFunction.Parameters, User> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<TeamNewFunctionParameters>, TeamNewFunctionParameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<TeamNewFunction.Parameters>, TeamNewFunction.Parameters>({
         id: Team.Id.builder,
         name: new ValueTypeBuilder(),
         paypalMeLink: new ValueTypeBuilder(),

package/src/functions/user/kickout.ts

@@ -2,14 +2,16 @@ import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Team, User } from '../../types';
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export type UserKickoutFunctionParameters = {
-    teamId: Team.Id
-    userId: User.Id
-};
+export namespace UserKickoutFunction {
 
-export abstract class UserKickoutFunctionBase extends FirebaseFunction<UserKickoutFunctionParameters, void> {
+    export type Parameters = {
+        teamId: Team.Id
+        userId: User.Id
+    };
+}
+export class UserKickoutFunction implements FirebaseFunction<UserKickoutFunction.Parameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<UserKickoutFunctionParameters>, UserKickoutFunctionParameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<UserKickoutFunction.Parameters>, UserKickoutFunction.Parameters>({
         teamId: Team.Id.builder,
         userId: User.Id.builder
     });

package/src/functions/user/login.ts

@@ -2,7 +2,7 @@ import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { User } from '../../types';
 import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 
-export abstract class UserLoginFunctionBase extends FirebaseFunction<null, User> {
+export class UserLoginFunction implements FirebaseFunction<null, User> {
 
     public parametersBuilder = new ValueTypeBuilder<null>();