volleyballsimtypes 0.0.359 → 0.0.361

package/dist/esm/src/data/models/competition-standings.d.ts

@@ -0,0 +1,47 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionId, CompetitionModel, TeamId, TeamModel } from '.';
+export interface CompetitionStandingsAttributes {
+    competition_id: string;
+    team_id: string;
+    position?: number | null;
+    won30: number;
+    won31: number;
+    won32: number;
+    lost03: number;
+    lost13: number;
+    lost23: number;
+    points_won: number;
+    points_lost: number;
+    points: number;
+    sets_won: number;
+    sets_lost: number;
+}
+export type CompetitionStandingsPk = 'competition_id' | 'team_id';
+export type CompetitionStandingsId = CompetitionStandingsModel[CompetitionStandingsPk];
+export type CompetitionStandingsCreationAttributes = CompetitionStandingsAttributes;
+export declare class CompetitionStandingsModel extends Model<CompetitionStandingsAttributes, CompetitionStandingsCreationAttributes> implements CompetitionStandingsAttributes {
+    competition_id: string;
+    team_id: string;
+    position: number | null;
+    won30: number;
+    won31: number;
+    won32: number;
+    lost03: number;
+    lost13: number;
+    lost23: number;
+    points_won: number;
+    points_lost: number;
+    points: number;
+    sets_won: number;
+    sets_lost: number;
+    Competition: CompetitionModel;
+    getCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    createCompetition: Sequelize.BelongsToCreateAssociationMixin<CompetitionModel>;
+    Team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CompetitionStandingsModel;
+}

package/dist/esm/src/data/models/competition-standings.js

@@ -0,0 +1,50 @@
+import { DataTypes, Model } from 'sequelize';
+export class CompetitionStandingsModel extends Model {
+    static initModel(sequelize) {
+        return CompetitionStandingsModel.init({
+            competition_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Competition',
+                    key: 'competition_id'
+                }
+            },
+            team_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            },
+            position: { type: DataTypes.INTEGER, allowNull: true },
+            won30: { type: DataTypes.BIGINT, allowNull: false },
+            won31: { type: DataTypes.BIGINT, allowNull: false },
+            won32: { type: DataTypes.BIGINT, allowNull: false },
+            lost03: { type: DataTypes.BIGINT, allowNull: false },
+            lost13: { type: DataTypes.BIGINT, allowNull: false },
+            lost23: { type: DataTypes.BIGINT, allowNull: false },
+            points_won: { type: DataTypes.DECIMAL, allowNull: false },
+            points_lost: { type: DataTypes.DECIMAL, allowNull: false },
+            points: { type: DataTypes.BIGINT, allowNull: false },
+            sets_won: { type: DataTypes.BIGINT, allowNull: false },
+            sets_lost: { type: DataTypes.BIGINT, allowNull: false }
+        }, {
+            sequelize,
+            tableName: 'CompetitionStandings',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'CompetitionStandings_pk',
+                    unique: true,
+                    fields: [
+                        { name: 'competition_id' },
+                        { name: 'team_id' }
+                    ]
+                }]
+        });
+    }
+}

package/dist/esm/src/data/models/competition-teams.d.ts

@@ -0,0 +1,25 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionId, CompetitionModel, TeamId, TeamModel } from '.';
+export interface CompetitionTeamsAttributes {
+    competition_id: string;
+    team_id: string;
+    index: number;
+}
+export type CompetitionTeamsPk = 'competition_id' | 'team_id';
+export type CompetitionTeamsId = CompetitionTeamsModel[CompetitionTeamsPk];
+export type CompetitionTeamsCreationAttributes = CompetitionTeamsAttributes;
+export declare class CompetitionTeamsModel extends Model<CompetitionTeamsAttributes, CompetitionTeamsCreationAttributes> implements CompetitionTeamsAttributes {
+    competition_id: string;
+    team_id: string;
+    index: number;
+    competition: CompetitionModel;
+    getCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    createCompetition: Sequelize.BelongsToCreateAssociationMixin<CompetitionModel>;
+    team: TeamModel;
+    getTeam: Sequelize.BelongsToGetAssociationMixin<TeamModel>;
+    setTeam: Sequelize.BelongsToSetAssociationMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToCreateAssociationMixin<TeamModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CompetitionTeamsModel;
+}

package/dist/esm/src/data/models/competition-teams.js

@@ -0,0 +1,42 @@
+import { DataTypes, Model } from 'sequelize';
+export class CompetitionTeamsModel extends Model {
+    static initModel(sequelize) {
+        return CompetitionTeamsModel.init({
+            competition_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Competition',
+                    key: 'competition_id'
+                }
+            },
+            team_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Team',
+                    key: 'team_id'
+                }
+            },
+            index: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'CompetitionTeams',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'competitionteams_pk',
+                    unique: true,
+                    fields: [
+                        { name: 'competition_id' },
+                        { name: 'team_id' }
+                    ]
+                }]
+        });
+    }
+}

package/dist/esm/src/data/models/competition.d.ts

@@ -0,0 +1,116 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionChampionAttributes, CompetitionChampionId, CompetitionChampionModel, CompetitionMVPAttributes, CompetitionMVPId, CompetitionMVPModel, CompetitionMatchAttributes, CompetitionMatchId, CompetitionMatchModel, CompetitionStandingsAttributes, CompetitionStandingsId, CompetitionStandingsModel, CompetitionTeamsAttributes, CompetitionTeamsId, CompetitionTeamsModel, PromotionMatchAttributes, PromotionMatchId, PromotionMatchModel, RegionQualifierAttributes, RegionQualifierId, RegionQualifierModel, DivisionSeasonAttributes, DivisionSeasonId, DivisionSeasonModel, IterationId, IterationModel, TeamId, TeamModel } from '.';
+import { Status } from '../common';
+export interface CompetitionAttributes {
+    competition_id: string;
+    iteration: number;
+    status: Status;
+    type: CompetitionType;
+    DivisionSeason?: DivisionSeasonAttributes;
+    CompetitionChampion?: CompetitionChampionAttributes;
+    CompetitionMVP?: CompetitionMVPAttributes;
+    CompetitionMatches?: CompetitionMatchAttributes[];
+    CompetitionStandings?: CompetitionStandingsAttributes[];
+    CompetitionTeams?: CompetitionTeamsAttributes[];
+    RegionQualifier?: RegionQualifierAttributes;
+    UpperPromotionMatches?: PromotionMatchAttributes[];
+    LowerPromotionMatches?: PromotionMatchAttributes[];
+}
+export type CompetitionPk = 'competition_id';
+export type CompetitionType = 'LEAGUE' | 'TOURNAMENT' | 'QUALIFIER';
+export type CompetitionId = CompetitionModel[CompetitionPk];
+export type CompetitionCreationAttributes = CompetitionAttributes;
+export declare class CompetitionModel extends Model<CompetitionAttributes, CompetitionCreationAttributes> implements CompetitionAttributes {
+    competition_id: string;
+    iteration: number;
+    type: CompetitionType;
+    status: Status;
+    CompetitionChampion: CompetitionChampionModel;
+    getCompetitionChampion: Sequelize.HasOneGetAssociationMixin<CompetitionChampionModel>;
+    setCompetitionChampion: Sequelize.HasOneSetAssociationMixin<CompetitionChampionModel, CompetitionChampionId>;
+    createCompetitionChampion: Sequelize.HasOneCreateAssociationMixin<CompetitionChampionModel>;
+    CompetitionMatches: CompetitionMatchModel[];
+    getCompetitionMatches: Sequelize.HasManyGetAssociationsMixin<CompetitionMatchModel>;
+    setCompetitionMatches: Sequelize.HasManySetAssociationsMixin<CompetitionMatchModel, CompetitionMatchId>;
+    addCompetitionMatch: Sequelize.HasManyAddAssociationMixin<CompetitionMatchModel, CompetitionMatchId>;
+    addCompetitionMatches: Sequelize.HasManyAddAssociationsMixin<CompetitionMatchModel, CompetitionMatchId>;
+    createCompetitionMatch: Sequelize.HasManyCreateAssociationMixin<CompetitionMatchModel>;
+    removeCompetitionMatch: Sequelize.HasManyRemoveAssociationMixin<CompetitionMatchModel, CompetitionMatchId>;
+    removeCompetitionMatches: Sequelize.HasManyRemoveAssociationsMixin<CompetitionMatchModel, CompetitionMatchId>;
+    hasCompetitionMatch: Sequelize.HasManyHasAssociationMixin<CompetitionMatchModel, CompetitionMatchId>;
+    hasCompetitionMatches: Sequelize.HasManyHasAssociationsMixin<CompetitionMatchModel, CompetitionMatchId>;
+    countCompetitionMatches: Sequelize.HasManyCountAssociationsMixin;
+    CompetitionStandings: CompetitionStandingsModel[];
+    getCompetitionStandings: Sequelize.HasManyGetAssociationsMixin<CompetitionStandingsModel>;
+    setCompetitionStandings: Sequelize.HasManySetAssociationsMixin<CompetitionStandingsModel, CompetitionStandingsId>;
+    addCompetitionStanding: Sequelize.HasManyAddAssociationMixin<CompetitionStandingsModel, CompetitionStandingsId>;
+    addCompetitionStandings: Sequelize.HasManyAddAssociationsMixin<CompetitionStandingsModel, CompetitionStandingsId>;
+    createCompetitionStanding: Sequelize.HasManyCreateAssociationMixin<CompetitionStandingsModel>;
+    removeCompetitionStanding: Sequelize.HasManyRemoveAssociationMixin<CompetitionStandingsModel, CompetitionStandingsId>;
+    removeCompetitionStandings: Sequelize.HasManyRemoveAssociationsMixin<CompetitionStandingsModel, CompetitionStandingsId>;
+    hasCompetitionStanding: Sequelize.HasManyHasAssociationMixin<CompetitionStandingsModel, CompetitionStandingsId>;
+    hasCompetitionStandings: Sequelize.HasManyHasAssociationsMixin<CompetitionStandingsModel, CompetitionStandingsId>;
+    countCompetitionStandings: Sequelize.HasManyCountAssociationsMixin;
+    CompetitionTeams: CompetitionTeamsModel[];
+    getCompetitionTeams: Sequelize.HasManyGetAssociationsMixin<CompetitionTeamsModel>;
+    setCompetitionTeams: Sequelize.HasManySetAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    addCompetitionTeam: Sequelize.HasManyAddAssociationMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    addCompetitionTeams: Sequelize.HasManyAddAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    createCompetitionTeam: Sequelize.HasManyCreateAssociationMixin<CompetitionTeamsModel>;
+    removeCompetitionTeam: Sequelize.HasManyRemoveAssociationMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    removeCompetitionTeams: Sequelize.HasManyRemoveAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    hasCompetitionTeam: Sequelize.HasManyHasAssociationMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    hasCompetitionTeams: Sequelize.HasManyHasAssociationsMixin<CompetitionTeamsModel, CompetitionTeamsId>;
+    countCompetitionTeams: Sequelize.HasManyCountAssociationsMixin;
+    RegionQualifier: RegionQualifierModel;
+    getRegionQualifier: Sequelize.HasOneGetAssociationMixin<RegionQualifierModel>;
+    setRegionQualifier: Sequelize.HasOneSetAssociationMixin<RegionQualifierModel, RegionQualifierId>;
+    createRegionQualifier: Sequelize.HasOneCreateAssociationMixin<RegionQualifierModel>;
+    UpperPromotionMatches: PromotionMatchModel[];
+    getUpperPromotionMatches: Sequelize.HasManyGetAssociationsMixin<PromotionMatchModel>;
+    setUpperPromotionMatches: Sequelize.HasManySetAssociationsMixin<PromotionMatchModel, PromotionMatchId>;
+    addUpperPromotionMatch: Sequelize.HasManyAddAssociationMixin<PromotionMatchModel, PromotionMatchId>;
+    addUpperPromotionMatches: Sequelize.HasManyAddAssociationsMixin<PromotionMatchModel, PromotionMatchId>;
+    createUpperPromotionMatch: Sequelize.HasManyCreateAssociationMixin<PromotionMatchModel>;
+    removeUpperPromotionMatch: Sequelize.HasManyRemoveAssociationMixin<PromotionMatchModel, PromotionMatchId>;
+    removeUpperPromotionMatches: Sequelize.HasManyRemoveAssociationsMixin<PromotionMatchModel, PromotionMatchId>;
+    hasUpperPromotionMatch: Sequelize.HasManyHasAssociationMixin<PromotionMatchModel, PromotionMatchId>;
+    hasUpperPromotionMatches: Sequelize.HasManyHasAssociationsMixin<PromotionMatchModel, PromotionMatchId>;
+    countUpperPromotionMatches: Sequelize.HasManyCountAssociationsMixin;
+    LowerPromotionMatches: PromotionMatchModel[];
+    getLowerPromotionMatches: Sequelize.HasManyGetAssociationsMixin<PromotionMatchModel>;
+    setLowerPromotionMatches: Sequelize.HasManySetAssociationsMixin<PromotionMatchModel, PromotionMatchId>;
+    addLowerPromotionMatch: Sequelize.HasManyAddAssociationMixin<PromotionMatchModel, PromotionMatchId>;
+    addLowerPromotionMatches: Sequelize.HasManyAddAssociationsMixin<PromotionMatchModel, PromotionMatchId>;
+    createLowerPromotionMatch: Sequelize.HasManyCreateAssociationMixin<PromotionMatchModel>;
+    removeLowerPromotionMatch: Sequelize.HasManyRemoveAssociationMixin<PromotionMatchModel, PromotionMatchId>;
+    removeLowerPromotionMatches: Sequelize.HasManyRemoveAssociationsMixin<PromotionMatchModel, PromotionMatchId>;
+    hasLowerPromotionMatch: Sequelize.HasManyHasAssociationMixin<PromotionMatchModel, PromotionMatchId>;
+    hasLowerPromotionMatches: Sequelize.HasManyHasAssociationsMixin<PromotionMatchModel, PromotionMatchId>;
+    countLowerPromotionMatches: Sequelize.HasManyCountAssociationsMixin;
+    CompetitionMVP: CompetitionMVPModel;
+    getCompetitionMVP: Sequelize.HasOneGetAssociationMixin<CompetitionMVPModel>;
+    setCompetitionMVP: Sequelize.HasOneSetAssociationMixin<CompetitionMVPModel, CompetitionMVPId>;
+    createCompetitionMVP: Sequelize.HasOneCreateAssociationMixin<CompetitionMVPModel>;
+    DivisionSeason: DivisionSeasonModel;
+    getDivisionSeason: Sequelize.HasOneGetAssociationMixin<DivisionSeasonModel>;
+    setDivisionSeason: Sequelize.HasOneSetAssociationMixin<DivisionSeasonModel, DivisionSeasonId>;
+    createDivisionSeason: Sequelize.HasOneCreateAssociationMixin<DivisionSeasonModel>;
+    Teams: TeamModel[];
+    getTeams: Sequelize.BelongsToManyGetAssociationsMixin<TeamModel>;
+    setTeams: Sequelize.BelongsToManySetAssociationsMixin<TeamModel, TeamId>;
+    addTeam: Sequelize.BelongsToManyAddAssociationMixin<TeamModel, TeamId>;
+    addTeams: Sequelize.BelongsToManyAddAssociationsMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.BelongsToManyCreateAssociationMixin<TeamModel>;
+    removeTeam: Sequelize.BelongsToManyRemoveAssociationMixin<TeamModel, TeamId>;
+    removeTeams: Sequelize.BelongsToManyRemoveAssociationsMixin<TeamModel, TeamId>;
+    hasTeam: Sequelize.BelongsToManyHasAssociationMixin<TeamModel, TeamId>;
+    hasTeams: Sequelize.BelongsToManyHasAssociationsMixin<TeamModel, TeamId>;
+    countTeams: Sequelize.BelongsToManyCountAssociationsMixin;
+    Iteration: IterationModel;
+    getIteration: Sequelize.BelongsToGetAssociationMixin<IterationModel>;
+    setIteration: Sequelize.BelongsToSetAssociationMixin<IterationModel, IterationId>;
+    createIteration: Sequelize.BelongsToCreateAssociationMixin<IterationModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CompetitionModel;
+}

package/dist/esm/src/data/models/competition.js

@@ -0,0 +1,53 @@
+import { DataTypes, Model } from 'sequelize';
+import { RegionQualifierModel, DivisionSeasonModel, IterationModel } from '.';
+import { StatusDataType } from '../common';
+export class CompetitionModel extends Model {
+    static initModel(sequelize) {
+        return CompetitionModel.init({
+            competition_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            iteration: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+                references: {
+                    model: 'Iteration',
+                    key: 'iteration_id'
+                }
+            },
+            type: {
+                type: DataTypes.ENUM('LEAGUE', 'TOURNAMENT', 'QUALIFIER'),
+                allowNull: false
+            },
+            status: {
+                type: StatusDataType,
+                allowNull: false,
+                defaultValue: 'PENDING'
+            }
+        }, {
+            sequelize,
+            tableName: 'Competition',
+            schema: 'public',
+            timestamps: false,
+            defaultScope: {
+                include: [{
+                        model: IterationModel,
+                        as: 'Iteration'
+                    }, {
+                        model: DivisionSeasonModel,
+                        as: 'DivisionSeason'
+                    }, {
+                        model: RegionQualifierModel,
+                        as: 'RegionQualifier'
+                    }]
+            },
+            indexes: [{
+                    name: 'competition_pk',
+                    unique: true,
+                    fields: [{ name: 'competition_id' }]
+                }]
+        });
+    }
+}

package/dist/esm/src/data/models/country.d.ts

@@ -0,0 +1,61 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { LeagueId, LeagueModel, PlayerId, PlayerModel, TeamId, TeamModel } from '.';
+export interface CountryAttributes {
+    country_id: string;
+    name: string;
+    alpha_2: string;
+    alpha_3: string;
+    country_code: string;
+    iso_3166_2: string;
+    region: string;
+    sub_region: string;
+    intermediate_region: string;
+    region_code: string;
+    sub_region_code: string;
+    intermediate_region_code: string;
+}
+export type CountryPk = 'country_id';
+export type CountryId = CountryModel[CountryPk];
+export type CountryCreationAttributes = CountryAttributes;
+export declare class CountryModel extends Model<CountryAttributes, CountryCreationAttributes> implements CountryAttributes {
+    country_id: string;
+    name: string;
+    alpha_2: string;
+    alpha_3: string;
+    country_code: string;
+    iso_3166_2: string;
+    region: string;
+    sub_region: string;
+    intermediate_region: string;
+    region_code: string;
+    sub_region_code: string;
+    intermediate_region_code: string;
+    League: LeagueModel;
+    getLeague: Sequelize.HasOneGetAssociationMixin<LeagueModel>;
+    setLeague: Sequelize.HasOneSetAssociationMixin<LeagueModel, LeagueId>;
+    createLeague: Sequelize.HasOneCreateAssociationMixin<LeagueModel>;
+    Players: PlayerModel[];
+    getPlayers: Sequelize.HasManyGetAssociationsMixin<PlayerModel>;
+    setPlayers: Sequelize.HasManySetAssociationsMixin<PlayerModel, PlayerId>;
+    addPlayer: Sequelize.HasManyAddAssociationMixin<PlayerModel, PlayerId>;
+    addPlayers: Sequelize.HasManyAddAssociationsMixin<PlayerModel, PlayerId>;
+    createPlayer: Sequelize.HasManyCreateAssociationMixin<PlayerModel>;
+    removePlayer: Sequelize.HasManyRemoveAssociationMixin<PlayerModel, PlayerId>;
+    removePlayers: Sequelize.HasManyRemoveAssociationsMixin<PlayerModel, PlayerId>;
+    hasPlayer: Sequelize.HasManyHasAssociationMixin<PlayerModel, PlayerId>;
+    hasPlayers: Sequelize.HasManyHasAssociationsMixin<PlayerModel, PlayerId>;
+    countPlayers: Sequelize.HasManyCountAssociationsMixin;
+    Teams: TeamModel[];
+    getTeams: Sequelize.HasManyGetAssociationsMixin<TeamModel>;
+    setTeams: Sequelize.HasManySetAssociationsMixin<TeamModel, TeamId>;
+    addTeam: Sequelize.HasManyAddAssociationMixin<TeamModel, TeamId>;
+    addTeams: Sequelize.HasManyAddAssociationsMixin<TeamModel, TeamId>;
+    createTeam: Sequelize.HasManyCreateAssociationMixin<TeamModel>;
+    removeTeam: Sequelize.HasManyRemoveAssociationMixin<TeamModel, TeamId>;
+    removeTeams: Sequelize.HasManyRemoveAssociationsMixin<TeamModel, TeamId>;
+    hasTeam: Sequelize.HasManyHasAssociationMixin<TeamModel, TeamId>;
+    hasTeams: Sequelize.HasManyHasAssociationsMixin<TeamModel, TeamId>;
+    countTeams: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CountryModel;
+}

package/dist/esm/src/data/models/country.js

@@ -0,0 +1,84 @@
+import { DataTypes, Model } from 'sequelize';
+export class CountryModel extends Model {
+    static initModel(sequelize) {
+        return CountryModel.init({
+            country_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            alpha_2: {
+                type: DataTypes.STRING(2),
+                allowNull: false
+            },
+            alpha_3: {
+                type: DataTypes.STRING(3),
+                allowNull: false
+            },
+            country_code: {
+                type: DataTypes.STRING(3),
+                allowNull: false
+            },
+            iso_3166_2: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            region: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            sub_region: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            intermediate_region: {
+                type: DataTypes.STRING,
+                allowNull: false,
+                defaultValue: ''
+            },
+            region_code: {
+                type: DataTypes.STRING(3),
+                allowNull: false
+            },
+            sub_region_code: {
+                type: DataTypes.STRING(3),
+                allowNull: false
+            },
+            intermediate_region_code: {
+                type: DataTypes.STRING(3),
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'Country',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'Country_pk',
+                    unique: true,
+                    fields: [{ name: 'country_id' }]
+                },
+                {
+                    name: 'Country_alpha_2_uq',
+                    unique: true,
+                    fields: [{ name: 'alpha_2' }]
+                },
+                {
+                    name: 'Country_alpha_3_uq',
+                    unique: true,
+                    fields: [{ name: 'alpha_3' }]
+                },
+                {
+                    name: 'Country_country_code_uq',
+                    unique: true,
+                    fields: [{ name: 'country_code' }]
+                }
+            ]
+        });
+    }
+}

package/dist/esm/src/data/models/currency-transaction.d.ts

@@ -0,0 +1,43 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { AuthUserId, AuthUserModel } from '.';
+export declare enum CurrencyTransactionTypeEnum {
+    INCOME = "INCOME",
+    EXPENSE = "EXPENSE"
+}
+export type CurrencyTransactionType = CurrencyTransactionTypeEnum.INCOME | CurrencyTransactionTypeEnum.EXPENSE;
+export declare enum CurrencyTransactionSourceEnum {
+    MATCH_REWARD = "MATCH_REWARD",
+    GACHA_PULL = "GACHA_PULL",
+    COACH_UPGRADE = "COACH_UPGRADE",
+    PLAYER_DISMISS = "PLAYER_DISMISS",
+    ADMIN_GRANT = "ADMIN_GRANT"
+}
+export type CurrencyTransactionSource = CurrencyTransactionSourceEnum.MATCH_REWARD | CurrencyTransactionSourceEnum.GACHA_PULL | CurrencyTransactionSourceEnum.COACH_UPGRADE | CurrencyTransactionSourceEnum.PLAYER_DISMISS | CurrencyTransactionSourceEnum.ADMIN_GRANT;
+export interface CurrencyTransactionAttributes {
+    transaction_id: string;
+    user_id: string;
+    amount: number;
+    type: CurrencyTransactionType;
+    source_type: CurrencyTransactionSource;
+    source_id: string | null;
+    created_at: Date;
+}
+export type CurrencyTransactionPk = 'transaction_id';
+export type CurrencyTransactionId = CurrencyTransactionModel[CurrencyTransactionPk];
+export type CurrencyTransactionOptionalAttributes = 'source_id' | 'created_at';
+export type CurrencyTransactionCreationAttributes = Sequelize.Optional<CurrencyTransactionAttributes, CurrencyTransactionOptionalAttributes>;
+export declare class CurrencyTransactionModel extends Model<CurrencyTransactionAttributes, CurrencyTransactionCreationAttributes> implements CurrencyTransactionAttributes {
+    transaction_id: string;
+    user_id: string;
+    amount: number;
+    type: CurrencyTransactionType;
+    source_type: CurrencyTransactionSource;
+    source_id: string | null;
+    created_at: Date;
+    user: AuthUserModel;
+    getUser: Sequelize.BelongsToGetAssociationMixin<AuthUserModel>;
+    setUser: Sequelize.BelongsToSetAssociationMixin<AuthUserModel, AuthUserId>;
+    createUser: Sequelize.BelongsToCreateAssociationMixin<AuthUserModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CurrencyTransactionModel;
+}

package/dist/esm/src/data/models/currency-transaction.js

@@ -0,0 +1,70 @@
+import { DataTypes, Model } from 'sequelize';
+export var CurrencyTransactionTypeEnum;
+(function (CurrencyTransactionTypeEnum) {
+    CurrencyTransactionTypeEnum["INCOME"] = "INCOME";
+    CurrencyTransactionTypeEnum["EXPENSE"] = "EXPENSE";
+})(CurrencyTransactionTypeEnum || (CurrencyTransactionTypeEnum = {}));
+export var CurrencyTransactionSourceEnum;
+(function (CurrencyTransactionSourceEnum) {
+    CurrencyTransactionSourceEnum["MATCH_REWARD"] = "MATCH_REWARD";
+    CurrencyTransactionSourceEnum["GACHA_PULL"] = "GACHA_PULL";
+    CurrencyTransactionSourceEnum["COACH_UPGRADE"] = "COACH_UPGRADE";
+    CurrencyTransactionSourceEnum["PLAYER_DISMISS"] = "PLAYER_DISMISS";
+    CurrencyTransactionSourceEnum["ADMIN_GRANT"] = "ADMIN_GRANT";
+})(CurrencyTransactionSourceEnum || (CurrencyTransactionSourceEnum = {}));
+export class CurrencyTransactionModel extends Model {
+    static initModel(sequelize) {
+        return CurrencyTransactionModel.init({
+            transaction_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true
+            },
+            user_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'AuthUser',
+                    key: 'user_id'
+                }
+            },
+            amount: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            type: {
+                type: DataTypes.ENUM(...Object.values(CurrencyTransactionTypeEnum)),
+                allowNull: false
+            },
+            source_type: {
+                type: DataTypes.ENUM(...Object.values(CurrencyTransactionSourceEnum)),
+                allowNull: false
+            },
+            source_id: {
+                type: DataTypes.UUID,
+                allowNull: true
+            },
+            created_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW
+            }
+        }, {
+            sequelize,
+            tableName: 'CurrencyTransaction',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: 'CurrencyTransaction_pk',
+                    unique: true,
+                    fields: [{ name: 'transaction_id' }]
+                },
+                {
+                    name: 'CurrencyTransaction_user_id_idx',
+                    fields: [{ name: 'user_id' }]
+                }
+            ]
+        });
+    }
+}

package/dist/esm/src/data/models/division-season.d.ts

@@ -0,0 +1,23 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import { CompetitionId, CompetitionModel, DivisionId, DivisionModel } from '.';
+export interface DivisionSeasonAttributes {
+    division_id: string;
+    competition_id: string;
+}
+export type DivisionSeasonPk = 'competition_id';
+export type DivisionSeasonId = DivisionSeasonModel[DivisionSeasonPk];
+export type DivisionSeasonCreationAttributes = DivisionSeasonAttributes;
+export declare class DivisionSeasonModel extends Model<DivisionSeasonAttributes, DivisionSeasonCreationAttributes> implements DivisionSeasonAttributes {
+    division_id: string;
+    competition_id: string;
+    competition: CompetitionModel;
+    getCompetition: Sequelize.BelongsToGetAssociationMixin<CompetitionModel>;
+    setCompetition: Sequelize.BelongsToSetAssociationMixin<CompetitionModel, CompetitionId>;
+    createCompetition: Sequelize.BelongsToCreateAssociationMixin<CompetitionModel>;
+    division: DivisionModel;
+    getDivision: Sequelize.BelongsToGetAssociationMixin<DivisionModel>;
+    setDivision: Sequelize.BelongsToSetAssociationMixin<DivisionModel, DivisionId>;
+    createDivision: Sequelize.BelongsToCreateAssociationMixin<DivisionModel>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof DivisionSeasonModel;
+}

package/dist/esm/src/data/models/division-season.js

@@ -0,0 +1,34 @@
+import { DataTypes, Model } from 'sequelize';
+export class DivisionSeasonModel extends Model {
+    static initModel(sequelize) {
+        return DivisionSeasonModel.init({
+            division_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'Division',
+                    key: 'division_id'
+                }
+            },
+            competition_id: {
+                type: DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'Competition',
+                    key: 'competition_id'
+                }
+            }
+        }, {
+            sequelize,
+            tableName: 'DivisionSeason',
+            schema: 'public',
+            timestamps: false,
+            indexes: [{
+                    name: 'divisionseason_pk',
+                    unique: true,
+                    fields: [{ name: 'competition_id' }]
+                }]
+        });
+    }
+}