@stevenkellner/team-conduct-api 1.0.3 → 1.0.5

package/lib/src/functions/team/new.d.ts

@@ -0,0 +1,26 @@
+import { ObjectTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
+import { Person, PersonPrivateProperties, User, Team } from '../../types';
+export declare namespace TeamNewFunction {
+    type Parameters = {
+        id: Team.Id;
+        name: string;
+        paypalMeLink: string | null;
+        personId: Person.Id;
+        personProperties: PersonPrivateProperties;
+    };
+}
+export declare class TeamNewFunction extends FirebaseFunction<TeamNewFunction.Parameters, User> {
+    parametersBuilder: ObjectTypeBuilder<{
+        id: string;
+        name: string;
+        paypalMeLink: string | null;
+        personId: string;
+        personProperties: {
+            firstName: string;
+            lastName: string | null;
+        };
+    }, TeamNewFunction.Parameters>;
+    returnTypeBuilder: User.TypeBuilder;
+    execute(parameters: TeamNewFunction.Parameters): Promise<User>;
+}

package/lib/src/functions/team/new.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeamNewFunction = void 0;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+const firebase_function_1 = require("@stevenkellner/firebase-function");
+const types_1 = require("../../types");
+const Firestore_1 = require("../../Firestore");
+class TeamNewFunction extends firebase_function_1.FirebaseFunction {
+    parametersBuilder = new typescript_common_functionality_1.ObjectTypeBuilder({
+        id: types_1.Team.Id.builder,
+        name: new typescript_common_functionality_1.ValueTypeBuilder(),
+        paypalMeLink: new typescript_common_functionality_1.ValueTypeBuilder(),
+        personId: types_1.Person.Id.builder,
+        personProperties: types_1.PersonPrivateProperties.builder
+    });
+    returnTypeBuilder = types_1.User.builder;
+    async execute(parameters) {
+        if (this.userId === null)
+            throw new firebase_function_1.FunctionsError('permission-denied', 'User is not authenticated');
+        const userId = types_1.User.Id.builder.build(this.userId);
+        const teamSnapshot = await Firestore_1.Firestore.shared.team(parameters.id).snapshot();
+        if (teamSnapshot.exists)
+            throw new firebase_function_1.FunctionsError('already-exists', 'Team already exists');
+        const userSnapshot = await Firestore_1.Firestore.shared.user(userId).snapshot();
+        let user = new types_1.User(userId);
+        if (userSnapshot.exists)
+            user = types_1.User.builder.build(userSnapshot.data);
+        user.teams.set(parameters.id, new types_1.User.TeamProperties(parameters.name, parameters.personId));
+        await Firestore_1.Firestore.shared.user(userId).set(user);
+        await Firestore_1.Firestore.shared.team(parameters.id).set(new types_1.Team(parameters.id, parameters.name, parameters.paypalMeLink));
+        const signInProperties = new types_1.PersonSignInProperties(userId, typescript_common_functionality_1.UtcDate.now, new types_1.NotificationProperties(), types_1.UserRole.all);
+        await Firestore_1.Firestore.shared.person(parameters.id, parameters.personId).set(new types_1.Person(parameters.personId, parameters.personProperties, [], signInProperties));
+        return user;
+    }
+}
+exports.TeamNewFunction = TeamNewFunction;

package/lib/src/functions/user/login.d.ts

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

package/lib/src/functions/user/login.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserLoginFunction = void 0;
+const firebase_function_1 = require("@stevenkellner/firebase-function");
+const types_1 = require("../../types");
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+const Firestore_1 = require("../../Firestore");
+class UserLoginFunction extends firebase_function_1.FirebaseFunction {
+    parametersBuilder = new typescript_common_functionality_1.ValueTypeBuilder();
+    returnTypeBuilder = types_1.User.builder;
+    async execute() {
+        if (this.userId === null)
+            throw new firebase_function_1.FunctionsError('unauthenticated', 'User is not authenticated.');
+        const userId = types_1.User.Id.builder.build(this.userId);
+        const userSnapshot = await Firestore_1.Firestore.shared.user(userId).snapshot();
+        if (!userSnapshot.exists)
+            throw new firebase_function_1.FunctionsError('not-found', 'User not found.');
+        return types_1.User.builder.build(userSnapshot.data);
+    }
+}
+exports.UserLoginFunction = UserLoginFunction;

package/lib/src/functions/user/roleEdit.d.ts

@@ -0,0 +1,19 @@
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
+import { Person, Team, UserRole } from '../../types';
+import { ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+export declare namespace UserRoleEditFunction {
+    type Parameters = {
+        teamId: Team.Id;
+        personId: Person.Id;
+        roles: UserRole[];
+    };
+}
+export declare class UserRoleEditFunction extends FirebaseFunction<UserRoleEditFunction.Parameters, void> {
+    parametersBuilder: ObjectTypeBuilder<{
+        teamId: string;
+        personId: string;
+        roles: UserRole[];
+    }, UserRoleEditFunction.Parameters>;
+    returnTypeBuilder: ValueTypeBuilder<void>;
+    execute(parameters: UserRoleEditFunction.Parameters): Promise<void>;
+}

package/lib/src/functions/user/roleEdit.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserRoleEditFunction = void 0;
+const firebase_function_1 = require("@stevenkellner/firebase-function");
+const checkAuthentication_1 = require("../../checkAuthentication");
+const types_1 = require("../../types");
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+const Firestore_1 = require("../../Firestore");
+class UserRoleEditFunction extends firebase_function_1.FirebaseFunction {
+    parametersBuilder = new typescript_common_functionality_1.ObjectTypeBuilder({
+        teamId: types_1.Team.Id.builder,
+        personId: types_1.Person.Id.builder,
+        roles: new typescript_common_functionality_1.ArrayTypeBuilder(new typescript_common_functionality_1.ValueTypeBuilder())
+    });
+    returnTypeBuilder = new typescript_common_functionality_1.ValueTypeBuilder();
+    async execute(parameters) {
+        const userId = await (0, checkAuthentication_1.checkAuthentication)(this.userId, parameters.teamId, 'team-manager');
+        const personSnapshot = await Firestore_1.Firestore.shared.person(parameters.teamId, parameters.personId).snapshot();
+        if (!personSnapshot.exists)
+            throw new firebase_function_1.FunctionsError('not-found', 'User does not exist');
+        const person = types_1.Person.builder.build(personSnapshot.data);
+        if (person.signInProperties === null)
+            throw new firebase_function_1.FunctionsError('permission-denied', 'User is not signed in');
+        if (person.signInProperties.userId.value === userId.value && !parameters.roles.includes('team-manager'))
+            throw new firebase_function_1.FunctionsError('unavailable', 'User cannot remove their own team-manager role');
+        person.signInProperties.roles = parameters.roles;
+        await Firestore_1.Firestore.shared.person(parameters.teamId, parameters.personId).set(person);
+    }
+}
+exports.UserRoleEditFunction = UserRoleEditFunction;

package/lib/src/pushNotification.d.ts

@@ -0,0 +1,3 @@
+import { NotificationProperties, Person, Team } from './types';
+import { Notification } from './firebase';
+export declare function pushNotification(teamId: Team.Id, personId: Person.Id, topic: NotificationProperties.Subscription, notification: Notification): Promise<void>;

package/lib/src/pushNotification.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pushNotification = pushNotification;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+const Firestore_1 = require("./Firestore");
+const types_1 = require("./types");
+const firebase_1 = require("./firebase");
+function successfulTokens(response, tokens) {
+    const successfulTokens = response.responses
+        .map((response, index) => ({
+        failed: response.error?.code === 'messaging/invalid-registration-token' || response.error?.code === 'messaging/registration-token-not-registered',
+        token: tokens[index]
+    }))
+        .filter(response => !response.failed)
+        .map(response => response.token);
+    const tokenDict = new typescript_common_functionality_1.Dictionary(types_1.NotificationProperties.TokenId.builder);
+    for (const token of successfulTokens)
+        tokenDict.set(types_1.NotificationProperties.TokenId.create(token), token);
+    return tokenDict;
+}
+async function pushNotification(teamId, personId, topic, notification) {
+    const personSnapshot = await Firestore_1.Firestore.shared.person(teamId, personId).snapshot();
+    if (!personSnapshot.exists)
+        return;
+    const person = types_1.Person.builder.build(personSnapshot.data);
+    if (person.signInProperties === null || !person.signInProperties.notificationProperties.subscriptions.includes(topic))
+        return;
+    const tokens = person.signInProperties.notificationProperties.tokens.values;
+    const response = await firebase_1.FirebaseConfiguration.shared.messaging.sendEachForMulticast({
+        tokens: tokens,
+        notification: notification
+    });
+    person.signInProperties.notificationProperties.tokens = successfulTokens(response, tokens);
+    await Firestore_1.Firestore.shared.person(teamId, personId).set(person);
+}

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

@@ -0,0 +1,27 @@
+import { Flattable, ITypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+export declare class Configuration implements Flattable<Configuration.Flatten> {
+    currency: Configuration.Currency;
+    locale: Configuration.Locale;
+    constructor(currency: Configuration.Currency, locale: Configuration.Locale);
+    get flatten(): Configuration.Flatten;
+}
+export declare namespace Configuration {
+    type Currency = 'EUR' | 'USD';
+    namespace Currency {
+        const all: Currency[];
+        const builder: ValueTypeBuilder<Currency>;
+    }
+    type Locale = 'de' | 'en';
+    namespace Locale {
+        const all: Locale[];
+        const builder: ValueTypeBuilder<Locale>;
+    }
+    type Flatten = {
+        currency: Currency;
+        locale: Locale;
+    };
+    class TypeBuilder implements ITypeBuilder<Flatten, Configuration> {
+        build(flatten: Flatten): Configuration;
+    }
+    const builder: TypeBuilder;
+}

package/lib/src/types/Configuration.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configuration = void 0;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+class Configuration {
+    currency;
+    locale;
+    constructor(currency, locale) {
+        this.currency = currency;
+        this.locale = locale;
+    }
+    get flatten() {
+        return {
+            currency: this.currency,
+            locale: this.locale
+        };
+    }
+}
+exports.Configuration = Configuration;
+(function (Configuration) {
+    let Currency;
+    (function (Currency) {
+        Currency.all = ['EUR', 'USD'];
+        Currency.builder = new typescript_common_functionality_1.ValueTypeBuilder();
+    })(Currency = Configuration.Currency || (Configuration.Currency = {}));
+    let Locale;
+    (function (Locale) {
+        Locale.all = ['de', 'en'];
+        Locale.builder = new typescript_common_functionality_1.ValueTypeBuilder();
+    })(Locale = Configuration.Locale || (Configuration.Locale = {}));
+    class TypeBuilder {
+        build(flatten) {
+            return new Configuration(flatten.currency, flatten.locale);
+        }
+    }
+    Configuration.TypeBuilder = TypeBuilder;
+    Configuration.builder = new TypeBuilder();
+})(Configuration || (exports.Configuration = Configuration = {}));

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

@@ -0,0 +1,30 @@
+import { Flattable, Guid, ITypeBuilder, Tagged, UtcDate } from '@stevenkellner/typescript-common-functionality';
+import { FineAmount } from './FineAmount';
+import { PayedState } from './PayedState';
+export declare class Fine implements Flattable<Fine.Flatten> {
+    id: Fine.Id;
+    payedState: PayedState;
+    date: UtcDate;
+    reason: string;
+    amount: FineAmount;
+    constructor(id: Fine.Id, payedState: PayedState, date: UtcDate, reason: string, amount: FineAmount);
+    get flatten(): Fine.Flatten;
+}
+export declare namespace Fine {
+    type Id = Tagged<Guid, 'fine'>;
+    namespace Id {
+        type Flatten = string;
+        const builder: Tagged.TypeBuilder<Guid, "fine">;
+    }
+    type Flatten = {
+        id: Id.Flatten;
+        payedState: PayedState;
+        date: UtcDate.Flatten;
+        reason: string;
+        amount: FineAmount.Flatten;
+    };
+    class TypeBuilder implements ITypeBuilder<Flatten, Fine> {
+        build(value: Flatten): Fine;
+    }
+    const builder: TypeBuilder;
+}

package/lib/src/types/Fine.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fine = void 0;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+const FineAmount_1 = require("./FineAmount");
+class Fine {
+    id;
+    payedState;
+    date;
+    reason;
+    amount;
+    constructor(id, payedState, date, reason, amount) {
+        this.id = id;
+        this.payedState = payedState;
+        this.date = date;
+        this.reason = reason;
+        this.amount = amount;
+    }
+    get flatten() {
+        return {
+            id: this.id.flatten,
+            payedState: this.payedState,
+            date: this.date.flatten,
+            reason: this.reason,
+            amount: this.amount.flatten
+        };
+    }
+}
+exports.Fine = Fine;
+(function (Fine) {
+    let Id;
+    (function (Id) {
+        Id.builder = typescript_common_functionality_1.Tagged.builder('fine', typescript_common_functionality_1.Guid.builder);
+    })(Id = Fine.Id || (Fine.Id = {}));
+    class TypeBuilder {
+        build(value) {
+            return new Fine(Id.builder.build(value.id), value.payedState, typescript_common_functionality_1.UtcDate.builder.build(value.date), value.reason, FineAmount_1.FineAmount.builder.build(value.amount));
+        }
+    }
+    Fine.TypeBuilder = TypeBuilder;
+    Fine.builder = new TypeBuilder();
+})(Fine || (exports.Fine = Fine = {}));

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

@@ -0,0 +1,51 @@
+import { Flattable, ITypeBuilder } from '@stevenkellner/typescript-common-functionality';
+import { MoneyAmount } from './MoneyAmount';
+import { Configuration } from './Configuration';
+export type FineAmount = FineAmount.Money | FineAmount.Item;
+export declare namespace FineAmount {
+    class Money implements Flattable<Money.Flatten> {
+        amount: MoneyAmount;
+        constructor(amount: MoneyAmount);
+        formatted(configuration: Configuration): string;
+        get flatten(): Money.Flatten;
+    }
+    namespace Money {
+        type Flatten = {
+            type: 'money';
+            amount: MoneyAmount.Flatten;
+        };
+        class TypeBuilder implements ITypeBuilder<Flatten, Money> {
+            build(value: Flatten): Money;
+        }
+        const builder: TypeBuilder;
+    }
+    class Item implements Flattable<Item.Flatten> {
+        item: Item.Type;
+        count: number;
+        constructor(item: Item.Type, count: number);
+        formatted(configuration: Configuration): string;
+        get flatten(): Item.Flatten;
+    }
+    namespace Item {
+        type Type = 'crateOfBeer';
+        namespace Type {
+            const all: Type[];
+        }
+        type Flatten = {
+            type: 'item';
+            item: Item.Type;
+            count: number;
+        };
+        class TypeBuilder implements ITypeBuilder<Flatten, Item> {
+            build(value: Flatten): Item;
+        }
+        const builder: TypeBuilder;
+    }
+    function money(MoneyAmount: MoneyAmount): Money;
+    function item(item: Item.Type, count: number): Item;
+    type Flatten = Money.Flatten | Item.Flatten;
+    class TypeBuilder implements ITypeBuilder<Flatten, FineAmount> {
+        build(value: Flatten): FineAmount;
+    }
+    const builder: TypeBuilder;
+}

package/lib/src/types/FineAmount.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FineAmount = void 0;
+const MoneyAmount_1 = require("./MoneyAmount");
+const i18n = __importStar(require("i18n"));
+var FineAmount;
+(function (FineAmount) {
+    class Money {
+        amount;
+        constructor(amount) {
+            this.amount = amount;
+        }
+        formatted(configuration) {
+            return this.amount.formatted(configuration.currency);
+        }
+        get flatten() {
+            return {
+                type: 'money',
+                amount: this.amount.flatten
+            };
+        }
+    }
+    FineAmount.Money = Money;
+    (function (Money) {
+        class TypeBuilder {
+            build(value) {
+                return new Money(MoneyAmount_1.MoneyAmount.builder.build(value.amount));
+            }
+        }
+        Money.TypeBuilder = TypeBuilder;
+        Money.builder = new TypeBuilder();
+    })(Money = FineAmount.Money || (FineAmount.Money = {}));
+    class Item {
+        item;
+        count;
+        constructor(item, count) {
+            this.item = item;
+            this.count = count;
+        }
+        formatted(configuration) {
+            const numberFormat = Intl.NumberFormat(configuration.locale, {
+                minimumFractionDigits: 0,
+                maximumFractionDigits: 0
+            });
+            if (this.count === 1)
+                return i18n.__(`FineAmount.Item.Type.${this.item}.singular`, numberFormat.format(this.count));
+            return i18n.__(`FineAmount.Item.Type.${this.item}.plural`, numberFormat.format(this.count));
+        }
+        get flatten() {
+            return {
+                type: 'item',
+                item: this.item,
+                count: this.count
+            };
+        }
+    }
+    FineAmount.Item = Item;
+    (function (Item) {
+        let Type;
+        (function (Type) {
+            Type.all = ['crateOfBeer'];
+        })(Type = Item.Type || (Item.Type = {}));
+        class TypeBuilder {
+            build(value) {
+                return new Item(value.item, value.count);
+            }
+        }
+        Item.TypeBuilder = TypeBuilder;
+        Item.builder = new TypeBuilder();
+    })(Item = FineAmount.Item || (FineAmount.Item = {}));
+    function money(MoneyAmount) {
+        return new Money(MoneyAmount);
+    }
+    FineAmount.money = money;
+    function item(item, count) {
+        return new Item(item, count);
+    }
+    FineAmount.item = item;
+    class TypeBuilder {
+        build(value) {
+            switch (value.type) {
+                case 'money':
+                    return Money.builder.build(value);
+                case 'item':
+                    return Item.builder.build(value);
+            }
+        }
+    }
+    FineAmount.TypeBuilder = TypeBuilder;
+    FineAmount.builder = new TypeBuilder();
+})(FineAmount || (exports.FineAmount = FineAmount = {}));

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

@@ -0,0 +1,28 @@
+import { Flattable, Guid, ITypeBuilder, Tagged } from '@stevenkellner/typescript-common-functionality';
+import { FineAmount } from './FineAmount';
+import { FineTemplateRepetition } from './FineTemplateRepetition';
+export declare class FineTemplate implements Flattable<FineTemplate.Flatten> {
+    id: FineTemplate.Id;
+    reason: string;
+    amount: FineAmount;
+    repetition: FineTemplateRepetition | null;
+    constructor(id: FineTemplate.Id, reason: string, amount: FineAmount, repetition: FineTemplateRepetition | null);
+    get flatten(): FineTemplate.Flatten;
+}
+export declare namespace FineTemplate {
+    type Id = Tagged<Guid, 'fineTemplate'>;
+    namespace Id {
+        type Flatten = string;
+        const builder: Tagged.TypeBuilder<Guid, "fineTemplate">;
+    }
+    type Flatten = {
+        id: Id.Flatten;
+        reason: string;
+        amount: FineAmount.Flatten;
+        repetition: FineTemplateRepetition.Flatten | null;
+    };
+    class TypeBuilder implements ITypeBuilder<Flatten, FineTemplate> {
+        build(value: Flatten): FineTemplate;
+    }
+    const builder: TypeBuilder;
+}

package/lib/src/types/FineTemplate.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FineTemplate = void 0;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+const FineAmount_1 = require("./FineAmount");
+const FineTemplateRepetition_1 = require("./FineTemplateRepetition");
+class FineTemplate {
+    id;
+    reason;
+    amount;
+    repetition;
+    constructor(id, reason, amount, repetition) {
+        this.id = id;
+        this.reason = reason;
+        this.amount = amount;
+        this.repetition = repetition;
+    }
+    get flatten() {
+        return {
+            id: this.id.flatten,
+            reason: this.reason,
+            amount: this.amount.flatten,
+            repetition: this.repetition === null ? null : this.repetition.flatten
+        };
+    }
+}
+exports.FineTemplate = FineTemplate;
+(function (FineTemplate) {
+    let Id;
+    (function (Id) {
+        Id.builder = typescript_common_functionality_1.Tagged.builder('fineTemplate', typescript_common_functionality_1.Guid.builder);
+    })(Id = FineTemplate.Id || (FineTemplate.Id = {}));
+    class TypeBuilder {
+        build(value) {
+            return new FineTemplate(Id.builder.build(value.id), value.reason, FineAmount_1.FineAmount.builder.build(value.amount), value.repetition === null ? null : FineTemplateRepetition_1.FineTemplateRepetition.builder.build(value.repetition));
+        }
+    }
+    FineTemplate.TypeBuilder = TypeBuilder;
+    FineTemplate.builder = new TypeBuilder();
+})(FineTemplate || (exports.FineTemplate = FineTemplate = {}));

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

@@ -0,0 +1,22 @@
+import { Flattable, ITypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+export declare class FineTemplateRepetition implements Flattable<FineTemplateRepetition.Flatten> {
+    item: FineTemplateRepetition.Item;
+    maxCount: number | null;
+    constructor(item: FineTemplateRepetition.Item, maxCount: number | null);
+    get flatten(): FineTemplateRepetition.Flatten;
+}
+export declare namespace FineTemplateRepetition {
+    type Item = 'minute' | 'day' | 'item' | 'count';
+    namespace Item {
+        const all: Item[];
+        const builder: ValueTypeBuilder<Item>;
+    }
+    type Flatten = {
+        item: Item;
+        maxCount: number | null;
+    };
+    class TypeBuilder implements ITypeBuilder<Flatten, FineTemplateRepetition> {
+        build(flatten: Flatten): FineTemplateRepetition;
+    }
+    const builder: TypeBuilder;
+}

package/lib/src/types/FineTemplateRepetition.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FineTemplateRepetition = void 0;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+class FineTemplateRepetition {
+    item;
+    maxCount;
+    constructor(item, maxCount) {
+        this.item = item;
+        this.maxCount = maxCount;
+    }
+    get flatten() {
+        return {
+            item: this.item,
+            maxCount: this.maxCount
+        };
+    }
+}
+exports.FineTemplateRepetition = FineTemplateRepetition;
+(function (FineTemplateRepetition) {
+    let Item;
+    (function (Item) {
+        Item.all = [
+            'minute',
+            'day',
+            'item',
+            'count'
+        ];
+        Item.builder = new typescript_common_functionality_1.ValueTypeBuilder();
+    })(Item = FineTemplateRepetition.Item || (FineTemplateRepetition.Item = {}));
+    class TypeBuilder {
+        build(flatten) {
+            return new FineTemplateRepetition(flatten.item, flatten.maxCount);
+        }
+    }
+    FineTemplateRepetition.TypeBuilder = TypeBuilder;
+    FineTemplateRepetition.builder = new TypeBuilder();
+})(FineTemplateRepetition || (exports.FineTemplateRepetition = FineTemplateRepetition = {}));

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

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