@earbug/db-models 0.0.1

package/dist/CanonGenre.js

@@ -0,0 +1,93 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanonGenre = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class CanonGenre extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonGenre.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+                primaryKey: true
+            },
+            name: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                unique: "genre_name_pkey"
+            },
+            asciiName: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                field: 'ascii_name'
+            },
+            description: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            parentGenreId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                field: 'parent_genre_id'
+            },
+            createDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'create_date'
+            },
+            updateDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'update_date'
+            }
+        }, {
+            sequelize,
+            tableName: 'canon_genre',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "genre_name_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "name" },
+                    ]
+                },
+                {
+                    name: "genre_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonGenre = CanonGenre;

package/dist/CanonGenreExternalReferenceRelation.d.ts

@@ -0,0 +1,31 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+export interface CanonGenreExternalReferenceRelationAttributes {
+    canonGenreId: string;
+    externalReferenceId: string;
+    url: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonGenreExternalReferenceRelationPk = "canonGenreId" | "externalReferenceId";
+export type CanonGenreExternalReferenceRelationId = CanonGenreExternalReferenceRelation[CanonGenreExternalReferenceRelationPk];
+export type CanonGenreExternalReferenceRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonGenreExternalReferenceRelationCreationAttributes = Optional<CanonGenreExternalReferenceRelationAttributes, CanonGenreExternalReferenceRelationOptionalAttributes>;
+export declare class CanonGenreExternalReferenceRelation extends Model<CanonGenreExternalReferenceRelationAttributes, CanonGenreExternalReferenceRelationCreationAttributes> implements CanonGenreExternalReferenceRelationAttributes {
+    canonGenreId: string;
+    externalReferenceId: string;
+    url: string;
+    createDate: Date;
+    updateDate: Date;
+    canonGenre: CanonGenre;
+    getCanonGenre: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
+    setCanonGenre: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
+    createCanonGenre: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
+    externalReference: ExternalReference;
+    getExternalReference: Sequelize.BelongsToGetAssociationMixin<ExternalReference>;
+    setExternalReference: Sequelize.BelongsToSetAssociationMixin<ExternalReference, ExternalReferenceId>;
+    createExternalReference: Sequelize.BelongsToCreateAssociationMixin<ExternalReference>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonGenreExternalReferenceRelation;
+}

package/dist/CanonGenreExternalReferenceRelation.js

@@ -0,0 +1,86 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanonGenreExternalReferenceRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class CanonGenreExternalReferenceRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonGenreExternalReferenceRelation.init({
+            canonGenreId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'canon_genre',
+                    key: 'id'
+                },
+                field: 'canon_genre_id'
+            },
+            externalReferenceId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'external_reference',
+                    key: 'id'
+                },
+                field: 'external_reference_id'
+            },
+            url: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            createDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'create_date'
+            },
+            updateDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'update_date'
+            }
+        }, {
+            sequelize,
+            tableName: 'canon_genre_external_reference_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "canon_genre_external_reference_relation_pk",
+                    unique: true,
+                    fields: [
+                        { name: "external_reference_id" },
+                        { name: "canon_genre_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonGenreExternalReferenceRelation = CanonGenreExternalReferenceRelation;

package/dist/CanonLabel.d.ts

@@ -0,0 +1,69 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonAlbumLabelRelation, CanonAlbumLabelRelationId } from './CanonAlbumLabelRelation';
+import type { CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId } from './CanonLabelExternalReferenceRelation';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+export interface CanonLabelAttributes {
+    id: string;
+    name: string;
+    asciiName: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonLabelPk = "id";
+export type CanonLabelId = CanonLabel[CanonLabelPk];
+export type CanonLabelOptionalAttributes = "id" | "createDate" | "updateDate";
+export type CanonLabelCreationAttributes = Optional<CanonLabelAttributes, CanonLabelOptionalAttributes>;
+export declare class CanonLabel extends Model<CanonLabelAttributes, CanonLabelCreationAttributes> implements CanonLabelAttributes {
+    id: string;
+    name: string;
+    asciiName: string;
+    createDate: Date;
+    updateDate: Date;
+    canonAlbumLabelRelations: CanonAlbumLabelRelation[];
+    getCanonAlbumLabelRelations: Sequelize.HasManyGetAssociationsMixin<CanonAlbumLabelRelation>;
+    setCanonAlbumLabelRelations: Sequelize.HasManySetAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+    addCanonAlbumLabelRelation: Sequelize.HasManyAddAssociationMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+    addCanonAlbumLabelRelations: Sequelize.HasManyAddAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+    createCanonAlbumLabelRelation: Sequelize.HasManyCreateAssociationMixin<CanonAlbumLabelRelation>;
+    removeCanonAlbumLabelRelation: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+    removeCanonAlbumLabelRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+    hasCanonAlbumLabelRelation: Sequelize.HasManyHasAssociationMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+    hasCanonAlbumLabelRelations: Sequelize.HasManyHasAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+    countCanonAlbumLabelRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonLabelExternalReferenceRelations: CanonLabelExternalReferenceRelation[];
+    getCanonLabelExternalReferenceRelations: Sequelize.HasManyGetAssociationsMixin<CanonLabelExternalReferenceRelation>;
+    setCanonLabelExternalReferenceRelations: Sequelize.HasManySetAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+    addCanonLabelExternalReferenceRelation: Sequelize.HasManyAddAssociationMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+    addCanonLabelExternalReferenceRelations: Sequelize.HasManyAddAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+    createCanonLabelExternalReferenceRelation: Sequelize.HasManyCreateAssociationMixin<CanonLabelExternalReferenceRelation>;
+    removeCanonLabelExternalReferenceRelation: Sequelize.HasManyRemoveAssociationMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+    removeCanonLabelExternalReferenceRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+    hasCanonLabelExternalReferenceRelation: Sequelize.HasManyHasAssociationMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+    hasCanonLabelExternalReferenceRelations: Sequelize.HasManyHasAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+    countCanonLabelExternalReferenceRelations: Sequelize.HasManyCountAssociationsMixin;
+    externalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations: ExternalReference[];
+    getExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations: Sequelize.BelongsToManyGetAssociationsMixin<ExternalReference>;
+    setExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations: Sequelize.BelongsToManySetAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    addExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelation: Sequelize.BelongsToManyAddAssociationMixin<ExternalReference, ExternalReferenceId>;
+    addExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations: Sequelize.BelongsToManyAddAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    createExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelation: Sequelize.BelongsToManyCreateAssociationMixin<ExternalReference>;
+    removeExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelation: Sequelize.BelongsToManyRemoveAssociationMixin<ExternalReference, ExternalReferenceId>;
+    removeExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    hasExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelation: Sequelize.BelongsToManyHasAssociationMixin<ExternalReference, ExternalReferenceId>;
+    hasExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations: Sequelize.BelongsToManyHasAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    countExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    canonAlbumIdPlatformAlbumCanonAlbumLabelRelations: PlatformAlbum[];
+    getCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
+    setCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    addCanonAlbumIdPlatformAlbumCanonAlbumLabelRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    addCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    createCanonAlbumIdPlatformAlbumCanonAlbumLabelRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformAlbum>;
+    removeCanonAlbumIdPlatformAlbumCanonAlbumLabelRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    removeCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    hasCanonAlbumIdPlatformAlbumCanonAlbumLabelRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    hasCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    countCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonLabel;
+}

package/dist/CanonLabel.js

@@ -0,0 +1,83 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanonLabel = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class CanonLabel extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonLabel.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+                primaryKey: true
+            },
+            name: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            asciiName: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                field: 'ascii_name'
+            },
+            createDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'create_date'
+            },
+            updateDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'update_date'
+            }
+        }, {
+            sequelize,
+            tableName: 'canon_label',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "label_name_idx",
+                    unique: true,
+                    fields: [
+                        { name: "name" },
+                    ]
+                },
+                {
+                    name: "label_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonLabel = CanonLabel;

package/dist/CanonLabelExternalReferenceRelation.d.ts

@@ -0,0 +1,31 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonLabel, CanonLabelId } from './CanonLabel';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+export interface CanonLabelExternalReferenceRelationAttributes {
+    canonLabelId: string;
+    externalReferenceId: string;
+    url: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonLabelExternalReferenceRelationPk = "canonLabelId" | "externalReferenceId";
+export type CanonLabelExternalReferenceRelationId = CanonLabelExternalReferenceRelation[CanonLabelExternalReferenceRelationPk];
+export type CanonLabelExternalReferenceRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonLabelExternalReferenceRelationCreationAttributes = Optional<CanonLabelExternalReferenceRelationAttributes, CanonLabelExternalReferenceRelationOptionalAttributes>;
+export declare class CanonLabelExternalReferenceRelation extends Model<CanonLabelExternalReferenceRelationAttributes, CanonLabelExternalReferenceRelationCreationAttributes> implements CanonLabelExternalReferenceRelationAttributes {
+    canonLabelId: string;
+    externalReferenceId: string;
+    url: string;
+    createDate: Date;
+    updateDate: Date;
+    canonLabel: CanonLabel;
+    getCanonLabel: Sequelize.BelongsToGetAssociationMixin<CanonLabel>;
+    setCanonLabel: Sequelize.BelongsToSetAssociationMixin<CanonLabel, CanonLabelId>;
+    createCanonLabel: Sequelize.BelongsToCreateAssociationMixin<CanonLabel>;
+    externalReference: ExternalReference;
+    getExternalReference: Sequelize.BelongsToGetAssociationMixin<ExternalReference>;
+    setExternalReference: Sequelize.BelongsToSetAssociationMixin<ExternalReference, ExternalReferenceId>;
+    createExternalReference: Sequelize.BelongsToCreateAssociationMixin<ExternalReference>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonLabelExternalReferenceRelation;
+}

package/dist/CanonLabelExternalReferenceRelation.js

@@ -0,0 +1,86 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanonLabelExternalReferenceRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class CanonLabelExternalReferenceRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonLabelExternalReferenceRelation.init({
+            canonLabelId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'canon_label',
+                    key: 'id'
+                },
+                field: 'canon_label_id'
+            },
+            externalReferenceId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'external_reference',
+                    key: 'id'
+                },
+                field: 'external_reference_id'
+            },
+            url: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            createDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'create_date'
+            },
+            updateDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'update_date'
+            }
+        }, {
+            sequelize,
+            tableName: 'canon_label_external_reference_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "canon_label_external_reference_relation_pk",
+                    unique: true,
+                    fields: [
+                        { name: "canon_label_id" },
+                        { name: "external_reference_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonLabelExternalReferenceRelation = CanonLabelExternalReferenceRelation;

package/dist/CanonMember.d.ts

@@ -0,0 +1,71 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonArtistMemberRelation, CanonArtistMemberRelationId } from './CanonArtistMemberRelation';
+import type { CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId } from './CanonMemberExternalReferenceRelation';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+export interface CanonMemberAttributes {
+    id: string;
+    name?: string;
+    asciiName?: string;
+    createDate?: Date;
+    updateDate?: Date;
+    isPast?: boolean;
+}
+export type CanonMemberPk = "id";
+export type CanonMemberId = CanonMember[CanonMemberPk];
+export type CanonMemberOptionalAttributes = "id" | "name" | "asciiName" | "createDate" | "updateDate" | "isPast";
+export type CanonMemberCreationAttributes = Optional<CanonMemberAttributes, CanonMemberOptionalAttributes>;
+export declare class CanonMember extends Model<CanonMemberAttributes, CanonMemberCreationAttributes> implements CanonMemberAttributes {
+    id: string;
+    name?: string;
+    asciiName?: string;
+    createDate?: Date;
+    updateDate?: Date;
+    isPast?: boolean;
+    canonArtistMemberRelations: CanonArtistMemberRelation[];
+    getCanonArtistMemberRelations: Sequelize.HasManyGetAssociationsMixin<CanonArtistMemberRelation>;
+    setCanonArtistMemberRelations: Sequelize.HasManySetAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+    addCanonArtistMemberRelation: Sequelize.HasManyAddAssociationMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+    addCanonArtistMemberRelations: Sequelize.HasManyAddAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+    createCanonArtistMemberRelation: Sequelize.HasManyCreateAssociationMixin<CanonArtistMemberRelation>;
+    removeCanonArtistMemberRelation: Sequelize.HasManyRemoveAssociationMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+    removeCanonArtistMemberRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+    hasCanonArtistMemberRelation: Sequelize.HasManyHasAssociationMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+    hasCanonArtistMemberRelations: Sequelize.HasManyHasAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+    countCanonArtistMemberRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonMemberExternalReferenceRelations: CanonMemberExternalReferenceRelation[];
+    getCanonMemberExternalReferenceRelations: Sequelize.HasManyGetAssociationsMixin<CanonMemberExternalReferenceRelation>;
+    setCanonMemberExternalReferenceRelations: Sequelize.HasManySetAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+    addCanonMemberExternalReferenceRelation: Sequelize.HasManyAddAssociationMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+    addCanonMemberExternalReferenceRelations: Sequelize.HasManyAddAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+    createCanonMemberExternalReferenceRelation: Sequelize.HasManyCreateAssociationMixin<CanonMemberExternalReferenceRelation>;
+    removeCanonMemberExternalReferenceRelation: Sequelize.HasManyRemoveAssociationMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+    removeCanonMemberExternalReferenceRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+    hasCanonMemberExternalReferenceRelation: Sequelize.HasManyHasAssociationMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+    hasCanonMemberExternalReferenceRelations: Sequelize.HasManyHasAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+    countCanonMemberExternalReferenceRelations: Sequelize.HasManyCountAssociationsMixin;
+    externalReferenceIdExternalReferenceCanonMemberExternalReferenceRelations: ExternalReference[];
+    getExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelations: Sequelize.BelongsToManyGetAssociationsMixin<ExternalReference>;
+    setExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelations: Sequelize.BelongsToManySetAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    addExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelation: Sequelize.BelongsToManyAddAssociationMixin<ExternalReference, ExternalReferenceId>;
+    addExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelations: Sequelize.BelongsToManyAddAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    createExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelation: Sequelize.BelongsToManyCreateAssociationMixin<ExternalReference>;
+    removeExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelation: Sequelize.BelongsToManyRemoveAssociationMixin<ExternalReference, ExternalReferenceId>;
+    removeExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    hasExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelation: Sequelize.BelongsToManyHasAssociationMixin<ExternalReference, ExternalReferenceId>;
+    hasExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelations: Sequelize.BelongsToManyHasAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    countExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    canonArtistIdPlatformArtistCanonArtistMemberRelations: PlatformArtist[];
+    getCanonArtistIdPlatformArtistCanonArtistMemberRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformArtist>;
+    setCanonArtistIdPlatformArtistCanonArtistMemberRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    addCanonArtistIdPlatformArtistCanonArtistMemberRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+    addCanonArtistIdPlatformArtistCanonArtistMemberRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    createCanonArtistIdPlatformArtistCanonArtistMemberRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformArtist>;
+    removeCanonArtistIdPlatformArtistCanonArtistMemberRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+    removeCanonArtistIdPlatformArtistCanonArtistMemberRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    hasCanonArtistIdPlatformArtistCanonArtistMemberRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+    hasCanonArtistIdPlatformArtistCanonArtistMemberRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    countCanonArtistIdPlatformArtistCanonArtistMemberRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonMember;
+}

package/dist/CanonMember.js

@@ -0,0 +1,82 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanonMember = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class CanonMember extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonMember.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+                primaryKey: true
+            },
+            name: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true
+            },
+            asciiName: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true,
+                field: 'ascii_name'
+            },
+            createDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'create_date'
+            },
+            updateDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'update_date'
+            },
+            isPast: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: true,
+                defaultValue: false,
+                field: 'is_past'
+            }
+        }, {
+            sequelize,
+            tableName: 'canon_member',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "member_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonMember = CanonMember;