@stevenkellner/team-conduct-api 2.0.2 → 2.0.4

package/lib/src/functions/fine/add.d.ts

@@ -1,13 +1,15 @@
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
 import { Configuration, Fine, Person, Team } from '../../types';
-export type FineAddFunctionParameters = {
-    teamId: Team.Id;
-    personId: Person.Id;
-    fine: Fine;
-    configuration: Configuration;
-};
-export declare abstract class FineAddFunctionBase extends FirebaseFunction<FineAddFunctionParameters, void> {
+export declare namespace FineAddFunction {
+    type Parameters = {
+        teamId: Team.Id;
+        personId: Person.Id;
+        fine: Fine;
+        configuration: Configuration;
+    };
+}
+export declare class FineAddFunction implements FirebaseFunction<FineAddFunction.Parameters, void> {
     parametersBuilder: ObjectTypeBuilder<{
         teamId: string;
         personId: string;
@@ -29,6 +31,6 @@ export declare abstract class FineAddFunctionBase extends FirebaseFunction<FineA
             currency: import("../../types").Currency;
             locale: import("../../types").Locale;
         };
-    }, FineAddFunctionParameters>;
+    }, FineAddFunction.Parameters>;
     returnTypeBuilder: ValueTypeBuilder<void>;
 }

package/lib/src/functions/fine/add.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FineAddFunctionBase = void 0;
-const firebase_function_1 = require("@stevenkellner/firebase-function");
+exports.FineAddFunction = void 0;
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
 const types_1 = require("../../types");
-class FineAddFunctionBase extends firebase_function_1.FirebaseFunction {
+class FineAddFunction {
     parametersBuilder = new typescript_common_functionality_1.ObjectTypeBuilder({
         teamId: types_1.Team.Id.builder,
         personId: types_1.Person.Id.builder,
@@ -13,4 +12,4 @@ class FineAddFunctionBase extends firebase_function_1.FirebaseFunction {
     });
     returnTypeBuilder = new typescript_common_functionality_1.ValueTypeBuilder();
 }
-exports.FineAddFunctionBase = FineAddFunctionBase;
+exports.FineAddFunction = FineAddFunction;

package/lib/src/functions/fine/delete.d.ts

@@ -1,13 +1,15 @@
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Configuration, Fine, Person, Team } from '../../types';
 import { ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-export type FineDeleteFunctionParameters = {
-    teamId: Team.Id;
-    personId: Person.Id;
-    id: Fine.Id;
-    configuration: Configuration;
-};
-export declare abstract class FineDeleteFunctionBase extends FirebaseFunction<FineDeleteFunctionParameters, void> {
+export declare namespace FineDeleteFunction {
+    type Parameters = {
+        teamId: Team.Id;
+        personId: Person.Id;
+        id: Fine.Id;
+        configuration: Configuration;
+    };
+}
+export declare class FineDeleteFunction implements FirebaseFunction<FineDeleteFunction.Parameters, void> {
     parametersBuilder: ObjectTypeBuilder<{
         teamId: string;
         personId: string;
@@ -16,6 +18,6 @@ export declare abstract class FineDeleteFunctionBase extends FirebaseFunction<Fi
             currency: import("../../types").Currency;
             locale: import("../../types").Locale;
         };
-    }, FineDeleteFunctionParameters>;
+    }, FineDeleteFunction.Parameters>;
     returnTypeBuilder: ValueTypeBuilder<void>;
 }

package/lib/src/functions/fine/delete.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FineDeleteFunctionBase = void 0;
-const firebase_function_1 = require("@stevenkellner/firebase-function");
+exports.FineDeleteFunction = void 0;
 const types_1 = require("../../types");
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
-class FineDeleteFunctionBase extends firebase_function_1.FirebaseFunction {
+class FineDeleteFunction {
     parametersBuilder = new typescript_common_functionality_1.ObjectTypeBuilder({
         teamId: types_1.Team.Id.builder,
         personId: types_1.Person.Id.builder,
@@ -13,4 +12,4 @@ class FineDeleteFunctionBase extends firebase_function_1.FirebaseFunction {
     });
     returnTypeBuilder = new typescript_common_functionality_1.ValueTypeBuilder();
 }
-exports.FineDeleteFunctionBase = FineDeleteFunctionBase;
+exports.FineDeleteFunction = FineDeleteFunction;

package/lib/src/functions/fine/update.d.ts

@@ -2,13 +2,15 @@ import { Configuration } from '../../types/Configuration';
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Fine, Person, Team } from '../../types';
 import { ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-export type FineUpdateFunctionParameters = {
-    teamId: Team.Id;
-    personId: Person.Id;
-    fine: Fine;
-    configuration: Configuration;
-};
-export declare abstract class FineUpdateFunctionBase extends FirebaseFunction<FineUpdateFunctionParameters, void> {
+export declare namespace FineUpdateFunction {
+    type Parameters = {
+        teamId: Team.Id;
+        personId: Person.Id;
+        fine: Fine;
+        configuration: Configuration;
+    };
+}
+export declare class FineUpdateFunction implements FirebaseFunction<FineUpdateFunction.Parameters, void> {
     parametersBuilder: ObjectTypeBuilder<{
         teamId: string;
         personId: string;
@@ -30,6 +32,6 @@ export declare abstract class FineUpdateFunctionBase extends FirebaseFunction<Fi
             currency: import("../../types").Currency;
             locale: import("../../types").Locale;
         };
-    }, FineUpdateFunctionParameters>;
+    }, FineUpdateFunction.Parameters>;
     returnTypeBuilder: ValueTypeBuilder<void>;
 }

package/lib/src/functions/fine/update.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FineUpdateFunctionBase = void 0;
+exports.FineUpdateFunction = void 0;
 const Configuration_1 = require("../../types/Configuration");
-const firebase_function_1 = require("@stevenkellner/firebase-function");
 const types_1 = require("../../types");
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
-class FineUpdateFunctionBase extends firebase_function_1.FirebaseFunction {
+class FineUpdateFunction {
     parametersBuilder = new typescript_common_functionality_1.ObjectTypeBuilder({
         teamId: types_1.Team.Id.builder,
         personId: types_1.Person.Id.builder,
@@ -14,4 +13,4 @@ class FineUpdateFunctionBase extends firebase_function_1.FirebaseFunction {
     });
     returnTypeBuilder = new typescript_common_functionality_1.ValueTypeBuilder();
 }
-exports.FineUpdateFunctionBase = FineUpdateFunctionBase;
+exports.FineUpdateFunction = FineUpdateFunction;

package/lib/src/functions/fineTemplate/add.d.ts

@@ -1,11 +1,13 @@
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { FineTemplate, Team } from '../../types';
 import { ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-export type FineTemplateAddFunctionParameters = {
-    teamId: Team.Id;
-    fineTemplate: FineTemplate;
-};
-export declare abstract class FineTemplateAddFunctionBase extends FirebaseFunction<FineTemplateAddFunctionParameters, void> {
+export declare namespace FineTemplateAddFunction {
+    type Parameters = {
+        teamId: Team.Id;
+        fineTemplate: FineTemplate;
+    };
+}
+export declare class FineTemplateAddFunction implements FirebaseFunction<FineTemplateAddFunction.Parameters, void> {
     parametersBuilder: ObjectTypeBuilder<{
         teamId: string;
         fineTemplate: {
@@ -24,6 +26,6 @@ export declare abstract class FineTemplateAddFunctionBase extends FirebaseFuncti
                 maxCount: number | null;
             } | null;
         };
-    }, FineTemplateAddFunctionParameters>;
+    }, FineTemplateAddFunction.Parameters>;
     returnTypeBuilder: ValueTypeBuilder<void>;
 }

package/lib/src/functions/fineTemplate/add.js

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FineTemplateAddFunctionBase = void 0;
-const firebase_function_1 = require("@stevenkellner/firebase-function");
+exports.FineTemplateAddFunction = void 0;
 const types_1 = require("../../types");
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
-class FineTemplateAddFunctionBase extends firebase_function_1.FirebaseFunction {
+class FineTemplateAddFunction {
     parametersBuilder = new typescript_common_functionality_1.ObjectTypeBuilder({
         teamId: types_1.Team.Id.builder,
         fineTemplate: types_1.FineTemplate.builder
     });
     returnTypeBuilder = new typescript_common_functionality_1.ValueTypeBuilder();
 }
-exports.FineTemplateAddFunctionBase = FineTemplateAddFunctionBase;
+exports.FineTemplateAddFunction = FineTemplateAddFunction;

package/lib/src/functions/fineTemplate/delete.d.ts

@@ -1,14 +1,16 @@
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { FineTemplate, Team } from '../../types';
 import { ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-export type FineTemplateDeleteFunctionParameters = {
-    teamId: Team.Id;
-    id: FineTemplate.Id;
-};
-export declare abstract class FineTemplateDeleteFunctionBase extends FirebaseFunction<FineTemplateDeleteFunctionParameters, void> {
+export declare namespace FineTemplateDeleteFunction {
+    type Parameters = {
+        teamId: Team.Id;
+        id: FineTemplate.Id;
+    };
+}
+export declare class FineTemplateDeleteFunction implements FirebaseFunction<FineTemplateDeleteFunction.Parameters, void> {
     parametersBuilder: ObjectTypeBuilder<{
         teamId: string;
         id: string;
-    }, FineTemplateDeleteFunctionParameters>;
+    }, FineTemplateDeleteFunction.Parameters>;
     returnTypeBuilder: ValueTypeBuilder<void>;
 }

package/lib/src/functions/fineTemplate/delete.js

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FineTemplateDeleteFunctionBase = void 0;
-const firebase_function_1 = require("@stevenkellner/firebase-function");
+exports.FineTemplateDeleteFunction = void 0;
 const types_1 = require("../../types");
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
-class FineTemplateDeleteFunctionBase extends firebase_function_1.FirebaseFunction {
+class FineTemplateDeleteFunction {
     parametersBuilder = new typescript_common_functionality_1.ObjectTypeBuilder({
         teamId: types_1.Team.Id.builder,
         id: types_1.FineTemplate.Id.builder
     });
     returnTypeBuilder = new typescript_common_functionality_1.ValueTypeBuilder();
 }
-exports.FineTemplateDeleteFunctionBase = FineTemplateDeleteFunctionBase;
+exports.FineTemplateDeleteFunction = FineTemplateDeleteFunction;

package/lib/src/functions/fineTemplate/update.d.ts

@@ -1,11 +1,13 @@
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { FineTemplate, Team } from '../../types';
 import { ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-export type FineTemplateUpdateFunctionParameters = {
-    teamId: Team.Id;
-    fineTemplate: FineTemplate;
-};
-export declare abstract class FineTemplateUpdateFunctionBase extends FirebaseFunction<FineTemplateUpdateFunctionParameters, void> {
+export declare namespace FineTemplateUpdateFunction {
+    type Parameters = {
+        teamId: Team.Id;
+        fineTemplate: FineTemplate;
+    };
+}
+export declare class FineTemplateUpdateFunction implements FirebaseFunction<FineTemplateUpdateFunction.Parameters, void> {
     parametersBuilder: ObjectTypeBuilder<{
         teamId: string;
         fineTemplate: {
@@ -24,6 +26,6 @@ export declare abstract class FineTemplateUpdateFunctionBase extends FirebaseFun
                 maxCount: number | null;
             } | null;
         };
-    }, FineTemplateUpdateFunctionParameters>;
+    }, FineTemplateUpdateFunction.Parameters>;
     returnTypeBuilder: ValueTypeBuilder<void>;
 }

package/lib/src/functions/fineTemplate/update.js

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FineTemplateUpdateFunctionBase = void 0;
-const firebase_function_1 = require("@stevenkellner/firebase-function");
+exports.FineTemplateUpdateFunction = void 0;
 const types_1 = require("../../types");
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
-class FineTemplateUpdateFunctionBase extends firebase_function_1.FirebaseFunction {
+class FineTemplateUpdateFunction {
     parametersBuilder = new typescript_common_functionality_1.ObjectTypeBuilder({
         teamId: types_1.Team.Id.builder,
         fineTemplate: types_1.FineTemplate.builder
     });
     returnTypeBuilder = new typescript_common_functionality_1.ValueTypeBuilder();
 }
-exports.FineTemplateUpdateFunctionBase = FineTemplateUpdateFunctionBase;
+exports.FineTemplateUpdateFunction = FineTemplateUpdateFunction;

package/lib/src/functions/firebaseFunctionsContext.d.ts

@@ -0,0 +1,39 @@
+import { TeamNewFunction, UserKickoutFunction, UserRoleEditFunction, PaypalMeEditFunction, NotificationRegisterFunction, NotificationSubscribeFunction, InvitationGetInvitationFunction, InvitationRegisterFunction, PersonAddFunction, PersonDeleteFunction, PersonUpdateFunction, FineTemplateAddFunction, FineTemplateDeleteFunction, FineTemplateUpdateFunction, FineAddFunction, FineDeleteFunction, FineUpdateFunction } from '.';
+export declare const firebaseFunctionsContext: {
+    team: {
+        new: import("@stevenkellner/firebase-function").FirebaseFunctionContext<TeamNewFunction.Parameters, import("..").User>;
+    };
+    user: {
+        kickout: import("@stevenkellner/firebase-function").FirebaseFunctionContext<UserKickoutFunction.Parameters, void>;
+        login: import("@stevenkellner/firebase-function").FirebaseFunctionContext<null, import("..").User>;
+        roleEdit: import("@stevenkellner/firebase-function").FirebaseFunctionContext<UserRoleEditFunction.Parameters, void>;
+    };
+    paypalMe: {
+        edit: import("@stevenkellner/firebase-function").FirebaseFunctionContext<PaypalMeEditFunction.Parameters, void>;
+    };
+    notification: {
+        register: import("@stevenkellner/firebase-function").FirebaseFunctionContext<NotificationRegisterFunction.Parameters, void>;
+        subscribe: import("@stevenkellner/firebase-function").FirebaseFunctionContext<NotificationSubscribeFunction.Parameters, void>;
+    };
+    invitation: {
+        invite: import("@stevenkellner/firebase-function").FirebaseFunctionContext<import("..").Invitation, import("@stevenkellner/typescript-common-functionality").Tagged<string, "invitation">>;
+        withdraw: import("@stevenkellner/firebase-function").FirebaseFunctionContext<import("..").Invitation, void>;
+        getInvitation: import("@stevenkellner/firebase-function").FirebaseFunctionContext<import("@stevenkellner/typescript-common-functionality").Tagged<string, "invitation">, InvitationGetInvitationFunction.ReturnType>;
+        register: import("@stevenkellner/firebase-function").FirebaseFunctionContext<InvitationRegisterFunction.Parameters, import("..").User>;
+    };
+    person: {
+        add: import("@stevenkellner/firebase-function").FirebaseFunctionContext<PersonAddFunction.Parameters, void>;
+        update: import("@stevenkellner/firebase-function").FirebaseFunctionContext<PersonUpdateFunction.Parameters, void>;
+        delete: import("@stevenkellner/firebase-function").FirebaseFunctionContext<PersonDeleteFunction.Parameters, void>;
+    };
+    fineTemplate: {
+        add: import("@stevenkellner/firebase-function").FirebaseFunctionContext<FineTemplateAddFunction.Parameters, void>;
+        update: import("@stevenkellner/firebase-function").FirebaseFunctionContext<FineTemplateUpdateFunction.Parameters, void>;
+        delete: import("@stevenkellner/firebase-function").FirebaseFunctionContext<FineTemplateDeleteFunction.Parameters, void>;
+    };
+    fine: {
+        add: import("@stevenkellner/firebase-function").FirebaseFunctionContext<FineAddFunction.Parameters, void>;
+        update: import("@stevenkellner/firebase-function").FirebaseFunctionContext<FineUpdateFunction.Parameters, void>;
+        delete: import("@stevenkellner/firebase-function").FirebaseFunctionContext<FineDeleteFunction.Parameters, void>;
+    };
+};

package/lib/src/functions/firebaseFunctionsContext.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firebaseFunctionsContext = void 0;
+const firebase_function_1 = require("@stevenkellner/firebase-function");
+const _1 = require(".");
+exports.firebaseFunctionsContext = firebase_function_1.FirebaseFunctionsContext.build(builder => ({
+    team: {
+        new: builder.function(_1.TeamNewFunction)
+    },
+    user: {
+        kickout: builder.function(_1.UserKickoutFunction),
+        login: builder.function(_1.UserLoginFunction),
+        roleEdit: builder.function(_1.UserRoleEditFunction)
+    },
+    paypalMe: {
+        edit: builder.function(_1.PaypalMeEditFunction)
+    },
+    notification: {
+        register: builder.function(_1.NotificationRegisterFunction),
+        subscribe: builder.function(_1.NotificationSubscribeFunction)
+    },
+    invitation: {
+        invite: builder.function(_1.InvitationInviteFunction),
+        withdraw: builder.function(_1.InvitationWithdrawFunction),
+        getInvitation: builder.function(_1.InvitationGetInvitationFunction),
+        register: builder.function(_1.InvitationRegisterFunction)
+    },
+    person: {
+        add: builder.function(_1.PersonAddFunction),
+        update: builder.function(_1.PersonUpdateFunction),
+        delete: builder.function(_1.PersonDeleteFunction)
+    },
+    fineTemplate: {
+        add: builder.function(_1.FineTemplateAddFunction),
+        update: builder.function(_1.FineTemplateUpdateFunction),
+        delete: builder.function(_1.FineTemplateDeleteFunction)
+    },
+    fine: {
+        add: builder.function(_1.FineAddFunction),
+        update: builder.function(_1.FineUpdateFunction),
+        delete: builder.function(_1.FineDeleteFunction)
+    }
+}));

package/lib/src/functions/index.d.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/lib/src/functions/index.js

@@ -34,3 +34,4 @@ __exportStar(require("./fine/delete"), exports);
 __exportStar(require("./fineTemplate/add"), exports);
 __exportStar(require("./fineTemplate/update"), exports);
 __exportStar(require("./fineTemplate/delete"), exports);
+__exportStar(require("./firebaseFunctionsContext"), exports);

package/lib/src/functions/invitation/getInvitation.d.ts

@@ -1,52 +1,54 @@
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Invitation, Person, PersonPrivateProperties, Team } from '../../types';
 import { Flattable, ITypeBuilder } from '@stevenkellner/typescript-common-functionality';
-export declare abstract class InvitationGetInvitationFunctionBase extends FirebaseFunction<Invitation.Id, InvitationGetInvitationFunctionReturnType> {
+export declare class InvitationGetInvitationFunction implements FirebaseFunction<Invitation.Id, InvitationGetInvitationFunction.ReturnType> {
     parametersBuilder: import("@stevenkellner/typescript-common-functionality").Tagged.TypeBuilder<string, "invitation">;
-    returnTypeBuilder: InvitationGetInvitationFunctionReturnType.TypeBuilder;
+    returnTypeBuilder: InvitationGetInvitationFunction.ReturnType.TypeBuilder;
 }
-export type PersonIdOrPersons = {
-    personId: Person.Id;
-} | {
-    persons: {
-        id: Person.Id;
-        properties: PersonPrivateProperties;
-    }[];
-};
-export declare namespace PersonIdOrPersons {
-    type Flatten = {
-        personId: Person.Id.Flatten;
+export declare namespace InvitationGetInvitationFunction {
+    type PersonIdOrPersons = {
+        personId: Person.Id;
     } | {
         persons: {
-            id: Person.Id.Flatten;
-            properties: PersonPrivateProperties.Flatten;
+            id: Person.Id;
+            properties: PersonPrivateProperties;
         }[];
     };
-}
-export declare class InvitationGetInvitationFunctionReturnType implements Flattable<InvitationGetInvitationFunctionReturnType.Flatten> {
-    teamId: Team.Id;
-    teamName: string;
-    private personIdOrPersons;
-    private constructor();
-    static from(teamId: Team.Id, teamName: string, personId: Person.Id): InvitationGetInvitationFunctionReturnType;
-    static from(teamId: Team.Id, teamName: string, persons: {
-        id: Person.Id;
-        properties: PersonPrivateProperties;
-    }[]): InvitationGetInvitationFunctionReturnType;
-    get personId(): Person.Id | null;
-    get persons(): {
-        id: Person.Id;
-        properties: PersonPrivateProperties;
-    }[] | null;
-    get flatten(): InvitationGetInvitationFunctionReturnType.Flatten;
-}
-export declare namespace InvitationGetInvitationFunctionReturnType {
-    type Flatten = {
-        teamId: Team.Id.Flatten;
+    namespace PersonIdOrPersons {
+        type Flatten = {
+            personId: Person.Id.Flatten;
+        } | {
+            persons: {
+                id: Person.Id.Flatten;
+                properties: PersonPrivateProperties.Flatten;
+            }[];
+        };
+    }
+    class ReturnType implements Flattable<ReturnType.Flatten> {
+        teamId: Team.Id;
         teamName: string;
-    } & PersonIdOrPersons.Flatten;
-    class TypeBuilder implements ITypeBuilder<Flatten, InvitationGetInvitationFunctionReturnType> {
-        build(value: Flatten): InvitationGetInvitationFunctionReturnType;
+        private personIdOrPersons;
+        private constructor();
+        static from(teamId: Team.Id, teamName: string, personId: Person.Id): ReturnType;
+        static from(teamId: Team.Id, teamName: string, persons: {
+            id: Person.Id;
+            properties: PersonPrivateProperties;
+        }[]): ReturnType;
+        get personId(): Person.Id | null;
+        get persons(): {
+            id: Person.Id;
+            properties: PersonPrivateProperties;
+        }[] | null;
+        get flatten(): ReturnType.Flatten;
+    }
+    namespace ReturnType {
+        type Flatten = {
+            teamId: Team.Id.Flatten;
+            teamName: string;
+        } & PersonIdOrPersons.Flatten;
+        class TypeBuilder implements ITypeBuilder<Flatten, ReturnType> {
+            build(value: Flatten): ReturnType;
+        }
+        const builder: TypeBuilder;
     }
-    const builder: TypeBuilder;
 }

package/lib/src/functions/invitation/getInvitation.js

@@ -1,73 +1,74 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvitationGetInvitationFunctionReturnType = exports.InvitationGetInvitationFunctionBase = void 0;
-const firebase_function_1 = require("@stevenkellner/firebase-function");
+exports.InvitationGetInvitationFunction = void 0;
 const types_1 = require("../../types");
-class InvitationGetInvitationFunctionBase extends firebase_function_1.FirebaseFunction {
+class InvitationGetInvitationFunction {
     parametersBuilder = types_1.Invitation.Id.builder;
-    returnTypeBuilder = InvitationGetInvitationFunctionReturnType.builder;
+    returnTypeBuilder = InvitationGetInvitationFunction.ReturnType.builder;
 }
-exports.InvitationGetInvitationFunctionBase = InvitationGetInvitationFunctionBase;
-class InvitationGetInvitationFunctionReturnType {
-    teamId;
-    teamName;
-    personIdOrPersons;
-    constructor(teamId, teamName, personIdOrPersons) {
-        this.teamId = teamId;
-        this.teamName = teamName;
-        this.personIdOrPersons = personIdOrPersons;
-    }
-    static from(teamId, teamName, personIdOrPersons) {
-        if (Array.isArray(personIdOrPersons)) {
-            return new InvitationGetInvitationFunctionReturnType(teamId, teamName, {
-                persons: personIdOrPersons
+exports.InvitationGetInvitationFunction = InvitationGetInvitationFunction;
+(function (InvitationGetInvitationFunction) {
+    class ReturnType {
+        teamId;
+        teamName;
+        personIdOrPersons;
+        constructor(teamId, teamName, personIdOrPersons) {
+            this.teamId = teamId;
+            this.teamName = teamName;
+            this.personIdOrPersons = personIdOrPersons;
+        }
+        static from(teamId, teamName, personIdOrPersons) {
+            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
-        });
-    }
-    get personId() {
-        if (!('personId' in this.personIdOrPersons))
-            return null;
-        return this.personIdOrPersons.personId;
-    }
-    get persons() {
-        if (!('persons' in this.personIdOrPersons))
-            return null;
-        return this.personIdOrPersons.persons;
-    }
-    get flatten() {
-        if ('personId' in this.personIdOrPersons) {
+        get personId() {
+            if (!('personId' in this.personIdOrPersons))
+                return null;
+            return this.personIdOrPersons.personId;
+        }
+        get persons() {
+            if (!('persons' in this.personIdOrPersons))
+                return null;
+            return this.personIdOrPersons.persons;
+        }
+        get 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
+                persons: this.personIdOrPersons.persons.map(person => ({
+                    id: person.id.flatten,
+                    properties: person.properties.flatten
+                }))
             };
         }
-        return {
-            teamId: this.teamId.flatten,
-            teamName: this.teamName,
-            persons: this.personIdOrPersons.persons.map(person => ({
-                id: person.id.flatten,
-                properties: person.properties.flatten
-            }))
-        };
     }
-}
-exports.InvitationGetInvitationFunctionReturnType = InvitationGetInvitationFunctionReturnType;
-(function (InvitationGetInvitationFunctionReturnType) {
-    class TypeBuilder {
-        build(value) {
-            if ('personId' in value) {
-                return InvitationGetInvitationFunctionReturnType.from(types_1.Team.Id.builder.build(value.teamId), value.teamName, types_1.Person.Id.builder.build(value.personId));
+    InvitationGetInvitationFunction.ReturnType = ReturnType;
+    (function (ReturnType) {
+        class TypeBuilder {
+            build(value) {
+                if ('personId' in value) {
+                    return ReturnType.from(types_1.Team.Id.builder.build(value.teamId), value.teamName, types_1.Person.Id.builder.build(value.personId));
+                }
+                return ReturnType.from(types_1.Team.Id.builder.build(value.teamId), value.teamName, value.persons.map(person => ({
+                    id: types_1.Person.Id.builder.build(person.id),
+                    properties: types_1.PersonPrivateProperties.builder.build(person.properties)
+                })));
             }
-            return InvitationGetInvitationFunctionReturnType.from(types_1.Team.Id.builder.build(value.teamId), value.teamName, value.persons.map(person => ({
-                id: types_1.Person.Id.builder.build(person.id),
-                properties: types_1.PersonPrivateProperties.builder.build(person.properties)
-            })));
         }
-    }
-    InvitationGetInvitationFunctionReturnType.TypeBuilder = TypeBuilder;
-    InvitationGetInvitationFunctionReturnType.builder = new TypeBuilder();
-})(InvitationGetInvitationFunctionReturnType || (exports.InvitationGetInvitationFunctionReturnType = InvitationGetInvitationFunctionReturnType = {}));
+        ReturnType.TypeBuilder = TypeBuilder;
+        ReturnType.builder = new TypeBuilder();
+    })(ReturnType = InvitationGetInvitationFunction.ReturnType || (InvitationGetInvitationFunction.ReturnType = {}));
+})(InvitationGetInvitationFunction || (exports.InvitationGetInvitationFunction = InvitationGetInvitationFunction = {}));

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

@@ -1,6 +1,6 @@
 import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Invitation } from '../../types';
-export declare abstract class InvitationInviteFunctionBase extends FirebaseFunction<Invitation, Invitation.Id> {
+export declare class InvitationInviteFunction implements FirebaseFunction<Invitation, Invitation.Id> {
     parametersBuilder: Invitation.TypeBuilder;
     returnTypeBuilder: import("@stevenkellner/typescript-common-functionality").Tagged.TypeBuilder<string, "invitation">;
 }