import * as Sequelize from 'sequelize';
import { Op } from 'sequelize';
import { DataTypes, Model, Optional } from 'sequelize';
import type { Apartment, ApartmentId } from './Apartment';
import type { Bed, BedId } from './Bed';
import type { Building, BuildingId } from './Building';
import type { ContractFile, ContractFileId } from './ContractFile';
import type { ContractType, ContractTypeId } from './ContractType';
import type { Contract, ContractId } from './Contract';
import type { EmailVerifyToken, EmailVerifyTokenId } from './EmailVerifyToken';
import type { File, FileId } from './File';
import type { IncidentFile, IncidentFileId } from './IncidentFile';
import type { IncidentType, IncidentTypeId } from './IncidentType';
import type { Incident, IncidentId } from './Incident';
import type { NotificationDevice, NotificationDeviceId } from './NotificationDevice';
import type { NotificationPreference, NotificationPreferenceId } from './NotificationPreference';
import type { NotificationReceipt, NotificationReceiptId } from './NotificationReceipt';
import type { NotificationTemplate, NotificationTemplateId } from './NotificationTemplate';
import type { PasswordResetToken, PasswordResetTokenId } from './PasswordResetToken';
import type { Permission, PermissionId } from './Permission';
import type { Post, PostId } from './Post';
import type { ResidentDocument, ResidentDocumentId } from './ResidentDocument';
import type { ResidentEvent, ResidentEventId } from './ResidentEvent';
import type { ResidentStay, ResidentStayId } from './ResidentStay';
import type { Resident, ResidentId } from './Resident';
import type { RolePermission, RolePermissionId } from './RolePermission';
import type { Role, RoleId } from './Role';
import type { Room, RoomId } from './Room';
import type { Technician, TechnicianId } from './Technician';
import type { UserAuth, UserAuthId } from './UserAuth';
import type { UserPasswordHistory, UserPasswordHistoryId } from './UserPasswordHistory';
import type { UserRole, UserRoleId } from './UserRole';
import type { UserSession, UserSessionId } from './UserSession';
export interface UserAttributes {
	id: string;
	email: string;
	username?: string | null;
	first_name?: string | null;
	last_name?: string | null;
	phone?: string | null;
	status?: 'active' | 'inactive' | 'suspended' | 'pending_verification' | null;
	created_by?: string | null;
	updated_by?: string | null;
	created_at?: Date | null;
	updated_at?: Date | null;
	deleted_at?: Date | null;
	avatar_id?: string | null;
}
export type UserPk = 'id';
export type UserId = User[UserPk];
export type UserOptionalAttributes =
	| 'id'
	| 'username'
	| 'first_name'
	| 'last_name'
	| 'phone'
	| 'status'
	| 'created_by'
	| 'updated_by'
	| 'created_at'
	| 'updated_at'
	| 'deleted_at'
	| 'avatar_id';
export type UserCreationAttributes = Optional<UserAttributes, UserOptionalAttributes>;
export class User extends Model<UserAttributes> implements UserAttributes {
	declare id: string;
	declare email: string;
	declare username?: string | null;
	declare first_name?: string | null;
	declare last_name?: string | null;
	declare phone?: string | null;
	declare status?: 'active' | 'inactive' | 'suspended' | 'pending_verification' | null;
	declare created_by?: string | null;
	declare updated_by?: string | null;
	declare created_at?: Date | null;
	declare updated_at?: Date | null;
	declare deleted_at?: Date | null;
	declare avatar_id?: string | null;
	// User belongsTo File via avatar_id
	declare avatar: File;
	declare getAvatar: Sequelize.BelongsToGetAssociationMixin<File>;
	declare setAvatar: Sequelize.BelongsToSetAssociationMixin<File, FileId>;
	declare createAvatar: Sequelize.BelongsToCreateAssociationMixin<File>;
	// User hasMany Apartment via created_by
	declare apartments: Apartment[];
	declare getApartments: Sequelize.HasManyGetAssociationsMixin<Apartment>;
	declare setApartments: Sequelize.HasManySetAssociationsMixin<Apartment, ApartmentId>;
	declare addApartment: Sequelize.HasManyAddAssociationMixin<Apartment, ApartmentId>;
	declare addApartments: Sequelize.HasManyAddAssociationsMixin<Apartment, ApartmentId>;
	declare createApartment: Sequelize.HasManyCreateAssociationMixin<Apartment>;
	declare removeApartment: Sequelize.HasManyRemoveAssociationMixin<Apartment, ApartmentId>;
	declare removeApartments: Sequelize.HasManyRemoveAssociationsMixin<Apartment, ApartmentId>;
	declare hasApartment: Sequelize.HasManyHasAssociationMixin<Apartment, ApartmentId>;
	declare hasApartments: Sequelize.HasManyHasAssociationsMixin<Apartment, ApartmentId>;
	declare countApartments: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Apartment via deleted_by
	declare deleted_by_apartments: Apartment[];
	declare getDeleted_by_apartments: Sequelize.HasManyGetAssociationsMixin<Apartment>;
	declare setDeleted_by_apartments: Sequelize.HasManySetAssociationsMixin<Apartment, ApartmentId>;
	declare addDeleted_by_apartment: Sequelize.HasManyAddAssociationMixin<Apartment, ApartmentId>;
	declare addDeleted_by_apartments: Sequelize.HasManyAddAssociationsMixin<Apartment, ApartmentId>;
	declare createDeleted_by_apartment: Sequelize.HasManyCreateAssociationMixin<Apartment>;
	declare removeDeleted_by_apartment: Sequelize.HasManyRemoveAssociationMixin<Apartment, ApartmentId>;
	declare removeDeleted_by_apartments: Sequelize.HasManyRemoveAssociationsMixin<Apartment, ApartmentId>;
	declare hasDeleted_by_apartment: Sequelize.HasManyHasAssociationMixin<Apartment, ApartmentId>;
	declare hasDeleted_by_apartments: Sequelize.HasManyHasAssociationsMixin<Apartment, ApartmentId>;
	declare countDeleted_by_apartments: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Apartment via updated_by
	declare updated_by_apartments: Apartment[];
	declare getUpdated_by_apartments: Sequelize.HasManyGetAssociationsMixin<Apartment>;
	declare setUpdated_by_apartments: Sequelize.HasManySetAssociationsMixin<Apartment, ApartmentId>;
	declare addUpdated_by_apartment: Sequelize.HasManyAddAssociationMixin<Apartment, ApartmentId>;
	declare addUpdated_by_apartments: Sequelize.HasManyAddAssociationsMixin<Apartment, ApartmentId>;
	declare createUpdated_by_apartment: Sequelize.HasManyCreateAssociationMixin<Apartment>;
	declare removeUpdated_by_apartment: Sequelize.HasManyRemoveAssociationMixin<Apartment, ApartmentId>;
	declare removeUpdated_by_apartments: Sequelize.HasManyRemoveAssociationsMixin<Apartment, ApartmentId>;
	declare hasUpdated_by_apartment: Sequelize.HasManyHasAssociationMixin<Apartment, ApartmentId>;
	declare hasUpdated_by_apartments: Sequelize.HasManyHasAssociationsMixin<Apartment, ApartmentId>;
	declare countUpdated_by_apartments: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Bed via created_by
	declare beds: Bed[];
	declare getBeds: Sequelize.HasManyGetAssociationsMixin<Bed>;
	declare setBeds: Sequelize.HasManySetAssociationsMixin<Bed, BedId>;
	declare addBed: Sequelize.HasManyAddAssociationMixin<Bed, BedId>;
	declare addBeds: Sequelize.HasManyAddAssociationsMixin<Bed, BedId>;
	declare createBed: Sequelize.HasManyCreateAssociationMixin<Bed>;
	declare removeBed: Sequelize.HasManyRemoveAssociationMixin<Bed, BedId>;
	declare removeBeds: Sequelize.HasManyRemoveAssociationsMixin<Bed, BedId>;
	declare hasBed: Sequelize.HasManyHasAssociationMixin<Bed, BedId>;
	declare hasBeds: Sequelize.HasManyHasAssociationsMixin<Bed, BedId>;
	declare countBeds: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Bed via deleted_by
	declare deleted_by_beds: Bed[];
	declare getDeleted_by_beds: Sequelize.HasManyGetAssociationsMixin<Bed>;
	declare setDeleted_by_beds: Sequelize.HasManySetAssociationsMixin<Bed, BedId>;
	declare addDeleted_by_bed: Sequelize.HasManyAddAssociationMixin<Bed, BedId>;
	declare addDeleted_by_beds: Sequelize.HasManyAddAssociationsMixin<Bed, BedId>;
	declare createDeleted_by_bed: Sequelize.HasManyCreateAssociationMixin<Bed>;
	declare removeDeleted_by_bed: Sequelize.HasManyRemoveAssociationMixin<Bed, BedId>;
	declare removeDeleted_by_beds: Sequelize.HasManyRemoveAssociationsMixin<Bed, BedId>;
	declare hasDeleted_by_bed: Sequelize.HasManyHasAssociationMixin<Bed, BedId>;
	declare hasDeleted_by_beds: Sequelize.HasManyHasAssociationsMixin<Bed, BedId>;
	declare countDeleted_by_beds: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Bed via updated_by
	declare updated_by_beds: Bed[];
	declare getUpdated_by_beds: Sequelize.HasManyGetAssociationsMixin<Bed>;
	declare setUpdated_by_beds: Sequelize.HasManySetAssociationsMixin<Bed, BedId>;
	declare addUpdated_by_bed: Sequelize.HasManyAddAssociationMixin<Bed, BedId>;
	declare addUpdated_by_beds: Sequelize.HasManyAddAssociationsMixin<Bed, BedId>;
	declare createUpdated_by_bed: Sequelize.HasManyCreateAssociationMixin<Bed>;
	declare removeUpdated_by_bed: Sequelize.HasManyRemoveAssociationMixin<Bed, BedId>;
	declare removeUpdated_by_beds: Sequelize.HasManyRemoveAssociationsMixin<Bed, BedId>;
	declare hasUpdated_by_bed: Sequelize.HasManyHasAssociationMixin<Bed, BedId>;
	declare hasUpdated_by_beds: Sequelize.HasManyHasAssociationsMixin<Bed, BedId>;
	declare countUpdated_by_beds: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Building via created_by
	declare buildings: Building[];
	declare getBuildings: Sequelize.HasManyGetAssociationsMixin<Building>;
	declare setBuildings: Sequelize.HasManySetAssociationsMixin<Building, BuildingId>;
	declare addBuilding: Sequelize.HasManyAddAssociationMixin<Building, BuildingId>;
	declare addBuildings: Sequelize.HasManyAddAssociationsMixin<Building, BuildingId>;
	declare createBuilding: Sequelize.HasManyCreateAssociationMixin<Building>;
	declare removeBuilding: Sequelize.HasManyRemoveAssociationMixin<Building, BuildingId>;
	declare removeBuildings: Sequelize.HasManyRemoveAssociationsMixin<Building, BuildingId>;
	declare hasBuilding: Sequelize.HasManyHasAssociationMixin<Building, BuildingId>;
	declare hasBuildings: Sequelize.HasManyHasAssociationsMixin<Building, BuildingId>;
	declare countBuildings: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Building via deleted_by
	declare deleted_by_buildings: Building[];
	declare getDeleted_by_buildings: Sequelize.HasManyGetAssociationsMixin<Building>;
	declare setDeleted_by_buildings: Sequelize.HasManySetAssociationsMixin<Building, BuildingId>;
	declare addDeleted_by_building: Sequelize.HasManyAddAssociationMixin<Building, BuildingId>;
	declare addDeleted_by_buildings: Sequelize.HasManyAddAssociationsMixin<Building, BuildingId>;
	declare createDeleted_by_building: Sequelize.HasManyCreateAssociationMixin<Building>;
	declare removeDeleted_by_building: Sequelize.HasManyRemoveAssociationMixin<Building, BuildingId>;
	declare removeDeleted_by_buildings: Sequelize.HasManyRemoveAssociationsMixin<Building, BuildingId>;
	declare hasDeleted_by_building: Sequelize.HasManyHasAssociationMixin<Building, BuildingId>;
	declare hasDeleted_by_buildings: Sequelize.HasManyHasAssociationsMixin<Building, BuildingId>;
	declare countDeleted_by_buildings: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Building via updated_by
	declare updated_by_buildings: Building[];
	declare getUpdated_by_buildings: Sequelize.HasManyGetAssociationsMixin<Building>;
	declare setUpdated_by_buildings: Sequelize.HasManySetAssociationsMixin<Building, BuildingId>;
	declare addUpdated_by_building: Sequelize.HasManyAddAssociationMixin<Building, BuildingId>;
	declare addUpdated_by_buildings: Sequelize.HasManyAddAssociationsMixin<Building, BuildingId>;
	declare createUpdated_by_building: Sequelize.HasManyCreateAssociationMixin<Building>;
	declare removeUpdated_by_building: Sequelize.HasManyRemoveAssociationMixin<Building, BuildingId>;
	declare removeUpdated_by_buildings: Sequelize.HasManyRemoveAssociationsMixin<Building, BuildingId>;
	declare hasUpdated_by_building: Sequelize.HasManyHasAssociationMixin<Building, BuildingId>;
	declare hasUpdated_by_buildings: Sequelize.HasManyHasAssociationsMixin<Building, BuildingId>;
	declare countUpdated_by_buildings: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany ContractFile via created_by
	declare contract_files: ContractFile[];
	declare getContract_files: Sequelize.HasManyGetAssociationsMixin<ContractFile>;
	declare setContract_files: Sequelize.HasManySetAssociationsMixin<ContractFile, ContractFileId>;
	declare addContract_file: Sequelize.HasManyAddAssociationMixin<ContractFile, ContractFileId>;
	declare addContract_files: Sequelize.HasManyAddAssociationsMixin<ContractFile, ContractFileId>;
	declare createContract_file: Sequelize.HasManyCreateAssociationMixin<ContractFile>;
	declare removeContract_file: Sequelize.HasManyRemoveAssociationMixin<ContractFile, ContractFileId>;
	declare removeContract_files: Sequelize.HasManyRemoveAssociationsMixin<ContractFile, ContractFileId>;
	declare hasContract_file: Sequelize.HasManyHasAssociationMixin<ContractFile, ContractFileId>;
	declare hasContract_files: Sequelize.HasManyHasAssociationsMixin<ContractFile, ContractFileId>;
	declare countContract_files: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany ContractFile via deleted_by
	declare deleted_by_contract_files: ContractFile[];
	declare getDeleted_by_contract_files: Sequelize.HasManyGetAssociationsMixin<ContractFile>;
	declare setDeleted_by_contract_files: Sequelize.HasManySetAssociationsMixin<ContractFile, ContractFileId>;
	declare addDeleted_by_contract_file: Sequelize.HasManyAddAssociationMixin<ContractFile, ContractFileId>;
	declare addDeleted_by_contract_files: Sequelize.HasManyAddAssociationsMixin<ContractFile, ContractFileId>;
	declare createDeleted_by_contract_file: Sequelize.HasManyCreateAssociationMixin<ContractFile>;
	declare removeDeleted_by_contract_file: Sequelize.HasManyRemoveAssociationMixin<ContractFile, ContractFileId>;
	declare removeDeleted_by_contract_files: Sequelize.HasManyRemoveAssociationsMixin<ContractFile, ContractFileId>;
	declare hasDeleted_by_contract_file: Sequelize.HasManyHasAssociationMixin<ContractFile, ContractFileId>;
	declare hasDeleted_by_contract_files: Sequelize.HasManyHasAssociationsMixin<ContractFile, ContractFileId>;
	declare countDeleted_by_contract_files: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany ContractFile via updated_by
	declare updated_by_contract_files: ContractFile[];
	declare getUpdated_by_contract_files: Sequelize.HasManyGetAssociationsMixin<ContractFile>;
	declare setUpdated_by_contract_files: Sequelize.HasManySetAssociationsMixin<ContractFile, ContractFileId>;
	declare addUpdated_by_contract_file: Sequelize.HasManyAddAssociationMixin<ContractFile, ContractFileId>;
	declare addUpdated_by_contract_files: Sequelize.HasManyAddAssociationsMixin<ContractFile, ContractFileId>;
	declare createUpdated_by_contract_file: Sequelize.HasManyCreateAssociationMixin<ContractFile>;
	declare removeUpdated_by_contract_file: Sequelize.HasManyRemoveAssociationMixin<ContractFile, ContractFileId>;
	declare removeUpdated_by_contract_files: Sequelize.HasManyRemoveAssociationsMixin<ContractFile, ContractFileId>;
	declare hasUpdated_by_contract_file: Sequelize.HasManyHasAssociationMixin<ContractFile, ContractFileId>;
	declare hasUpdated_by_contract_files: Sequelize.HasManyHasAssociationsMixin<ContractFile, ContractFileId>;
	declare countUpdated_by_contract_files: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany ContractType via created_by
	declare contract_types: ContractType[];
	declare getContract_types: Sequelize.HasManyGetAssociationsMixin<ContractType>;
	declare setContract_types: Sequelize.HasManySetAssociationsMixin<ContractType, ContractTypeId>;
	declare addContract_type: Sequelize.HasManyAddAssociationMixin<ContractType, ContractTypeId>;
	declare addContract_types: Sequelize.HasManyAddAssociationsMixin<ContractType, ContractTypeId>;
	declare createContract_type: Sequelize.HasManyCreateAssociationMixin<ContractType>;
	declare removeContract_type: Sequelize.HasManyRemoveAssociationMixin<ContractType, ContractTypeId>;
	declare removeContract_types: Sequelize.HasManyRemoveAssociationsMixin<ContractType, ContractTypeId>;
	declare hasContract_type: Sequelize.HasManyHasAssociationMixin<ContractType, ContractTypeId>;
	declare hasContract_types: Sequelize.HasManyHasAssociationsMixin<ContractType, ContractTypeId>;
	declare countContract_types: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany ContractType via deleted_by
	declare deleted_by_contract_types: ContractType[];
	declare getDeleted_by_contract_types: Sequelize.HasManyGetAssociationsMixin<ContractType>;
	declare setDeleted_by_contract_types: Sequelize.HasManySetAssociationsMixin<ContractType, ContractTypeId>;
	declare addDeleted_by_contract_type: Sequelize.HasManyAddAssociationMixin<ContractType, ContractTypeId>;
	declare addDeleted_by_contract_types: Sequelize.HasManyAddAssociationsMixin<ContractType, ContractTypeId>;
	declare createDeleted_by_contract_type: Sequelize.HasManyCreateAssociationMixin<ContractType>;
	declare removeDeleted_by_contract_type: Sequelize.HasManyRemoveAssociationMixin<ContractType, ContractTypeId>;
	declare removeDeleted_by_contract_types: Sequelize.HasManyRemoveAssociationsMixin<ContractType, ContractTypeId>;
	declare hasDeleted_by_contract_type: Sequelize.HasManyHasAssociationMixin<ContractType, ContractTypeId>;
	declare hasDeleted_by_contract_types: Sequelize.HasManyHasAssociationsMixin<ContractType, ContractTypeId>;
	declare countDeleted_by_contract_types: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany ContractType via updated_by
	declare updated_by_contract_types: ContractType[];
	declare getUpdated_by_contract_types: Sequelize.HasManyGetAssociationsMixin<ContractType>;
	declare setUpdated_by_contract_types: Sequelize.HasManySetAssociationsMixin<ContractType, ContractTypeId>;
	declare addUpdated_by_contract_type: Sequelize.HasManyAddAssociationMixin<ContractType, ContractTypeId>;
	declare addUpdated_by_contract_types: Sequelize.HasManyAddAssociationsMixin<ContractType, ContractTypeId>;
	declare createUpdated_by_contract_type: Sequelize.HasManyCreateAssociationMixin<ContractType>;
	declare removeUpdated_by_contract_type: Sequelize.HasManyRemoveAssociationMixin<ContractType, ContractTypeId>;
	declare removeUpdated_by_contract_types: Sequelize.HasManyRemoveAssociationsMixin<ContractType, ContractTypeId>;
	declare hasUpdated_by_contract_type: Sequelize.HasManyHasAssociationMixin<ContractType, ContractTypeId>;
	declare hasUpdated_by_contract_types: Sequelize.HasManyHasAssociationsMixin<ContractType, ContractTypeId>;
	declare countUpdated_by_contract_types: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Contract via created_by
	declare contracts: Contract[];
	declare getContracts: Sequelize.HasManyGetAssociationsMixin<Contract>;
	declare setContracts: Sequelize.HasManySetAssociationsMixin<Contract, ContractId>;
	declare addContract: Sequelize.HasManyAddAssociationMixin<Contract, ContractId>;
	declare addContracts: Sequelize.HasManyAddAssociationsMixin<Contract, ContractId>;
	declare createContract: Sequelize.HasManyCreateAssociationMixin<Contract>;
	declare removeContract: Sequelize.HasManyRemoveAssociationMixin<Contract, ContractId>;
	declare removeContracts: Sequelize.HasManyRemoveAssociationsMixin<Contract, ContractId>;
	declare hasContract: Sequelize.HasManyHasAssociationMixin<Contract, ContractId>;
	declare hasContracts: Sequelize.HasManyHasAssociationsMixin<Contract, ContractId>;
	declare countContracts: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Contract via deleted_by
	declare deleted_by_contracts: Contract[];
	declare getDeleted_by_contracts: Sequelize.HasManyGetAssociationsMixin<Contract>;
	declare setDeleted_by_contracts: Sequelize.HasManySetAssociationsMixin<Contract, ContractId>;
	declare addDeleted_by_contract: Sequelize.HasManyAddAssociationMixin<Contract, ContractId>;
	declare addDeleted_by_contracts: Sequelize.HasManyAddAssociationsMixin<Contract, ContractId>;
	declare createDeleted_by_contract: Sequelize.HasManyCreateAssociationMixin<Contract>;
	declare removeDeleted_by_contract: Sequelize.HasManyRemoveAssociationMixin<Contract, ContractId>;
	declare removeDeleted_by_contracts: Sequelize.HasManyRemoveAssociationsMixin<Contract, ContractId>;
	declare hasDeleted_by_contract: Sequelize.HasManyHasAssociationMixin<Contract, ContractId>;
	declare hasDeleted_by_contracts: Sequelize.HasManyHasAssociationsMixin<Contract, ContractId>;
	declare countDeleted_by_contracts: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Contract via updated_by
	declare updated_by_contracts: Contract[];
	declare getUpdated_by_contracts: Sequelize.HasManyGetAssociationsMixin<Contract>;
	declare setUpdated_by_contracts: Sequelize.HasManySetAssociationsMixin<Contract, ContractId>;
	declare addUpdated_by_contract: Sequelize.HasManyAddAssociationMixin<Contract, ContractId>;
	declare addUpdated_by_contracts: Sequelize.HasManyAddAssociationsMixin<Contract, ContractId>;
	declare createUpdated_by_contract: Sequelize.HasManyCreateAssociationMixin<Contract>;
	declare removeUpdated_by_contract: Sequelize.HasManyRemoveAssociationMixin<Contract, ContractId>;
	declare removeUpdated_by_contracts: Sequelize.HasManyRemoveAssociationsMixin<Contract, ContractId>;
	declare hasUpdated_by_contract: Sequelize.HasManyHasAssociationMixin<Contract, ContractId>;
	declare hasUpdated_by_contracts: Sequelize.HasManyHasAssociationsMixin<Contract, ContractId>;
	declare countUpdated_by_contracts: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany EmailVerifyToken via user_id
	declare email_verify_tokens: EmailVerifyToken[];
	declare getEmail_verify_tokens: Sequelize.HasManyGetAssociationsMixin<EmailVerifyToken>;
	declare setEmail_verify_tokens: Sequelize.HasManySetAssociationsMixin<EmailVerifyToken, EmailVerifyTokenId>;
	declare addEmail_verify_token: Sequelize.HasManyAddAssociationMixin<EmailVerifyToken, EmailVerifyTokenId>;
	declare addEmail_verify_tokens: Sequelize.HasManyAddAssociationsMixin<EmailVerifyToken, EmailVerifyTokenId>;
	declare createEmail_verify_token: Sequelize.HasManyCreateAssociationMixin<EmailVerifyToken>;
	declare removeEmail_verify_token: Sequelize.HasManyRemoveAssociationMixin<EmailVerifyToken, EmailVerifyTokenId>;
	declare removeEmail_verify_tokens: Sequelize.HasManyRemoveAssociationsMixin<EmailVerifyToken, EmailVerifyTokenId>;
	declare hasEmail_verify_token: Sequelize.HasManyHasAssociationMixin<EmailVerifyToken, EmailVerifyTokenId>;
	declare hasEmail_verify_tokens: Sequelize.HasManyHasAssociationsMixin<EmailVerifyToken, EmailVerifyTokenId>;
	declare countEmail_verify_tokens: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany File via created_by
	declare files: File[];
	declare getFiles: Sequelize.HasManyGetAssociationsMixin<File>;
	declare setFiles: Sequelize.HasManySetAssociationsMixin<File, FileId>;
	declare addFile: Sequelize.HasManyAddAssociationMixin<File, FileId>;
	declare addFiles: Sequelize.HasManyAddAssociationsMixin<File, FileId>;
	declare createFile: Sequelize.HasManyCreateAssociationMixin<File>;
	declare removeFile: Sequelize.HasManyRemoveAssociationMixin<File, FileId>;
	declare removeFiles: Sequelize.HasManyRemoveAssociationsMixin<File, FileId>;
	declare hasFile: Sequelize.HasManyHasAssociationMixin<File, FileId>;
	declare hasFiles: Sequelize.HasManyHasAssociationsMixin<File, FileId>;
	declare countFiles: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany File via deleted_by
	declare deleted_by_files: File[];
	declare getDeleted_by_files: Sequelize.HasManyGetAssociationsMixin<File>;
	declare setDeleted_by_files: Sequelize.HasManySetAssociationsMixin<File, FileId>;
	declare addDeleted_by_file: Sequelize.HasManyAddAssociationMixin<File, FileId>;
	declare addDeleted_by_files: Sequelize.HasManyAddAssociationsMixin<File, FileId>;
	declare createDeleted_by_file: Sequelize.HasManyCreateAssociationMixin<File>;
	declare removeDeleted_by_file: Sequelize.HasManyRemoveAssociationMixin<File, FileId>;
	declare removeDeleted_by_files: Sequelize.HasManyRemoveAssociationsMixin<File, FileId>;
	declare hasDeleted_by_file: Sequelize.HasManyHasAssociationMixin<File, FileId>;
	declare hasDeleted_by_files: Sequelize.HasManyHasAssociationsMixin<File, FileId>;
	declare countDeleted_by_files: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany File via owner_user_id
	declare owner_user_files: File[];
	declare getOwner_user_files: Sequelize.HasManyGetAssociationsMixin<File>;
	declare setOwner_user_files: Sequelize.HasManySetAssociationsMixin<File, FileId>;
	declare addOwner_user_file: Sequelize.HasManyAddAssociationMixin<File, FileId>;
	declare addOwner_user_files: Sequelize.HasManyAddAssociationsMixin<File, FileId>;
	declare createOwner_user_file: Sequelize.HasManyCreateAssociationMixin<File>;
	declare removeOwner_user_file: Sequelize.HasManyRemoveAssociationMixin<File, FileId>;
	declare removeOwner_user_files: Sequelize.HasManyRemoveAssociationsMixin<File, FileId>;
	declare hasOwner_user_file: Sequelize.HasManyHasAssociationMixin<File, FileId>;
	declare hasOwner_user_files: Sequelize.HasManyHasAssociationsMixin<File, FileId>;
	declare countOwner_user_files: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany File via updated_by
	declare updated_by_files: File[];
	declare getUpdated_by_files: Sequelize.HasManyGetAssociationsMixin<File>;
	declare setUpdated_by_files: Sequelize.HasManySetAssociationsMixin<File, FileId>;
	declare addUpdated_by_file: Sequelize.HasManyAddAssociationMixin<File, FileId>;
	declare addUpdated_by_files: Sequelize.HasManyAddAssociationsMixin<File, FileId>;
	declare createUpdated_by_file: Sequelize.HasManyCreateAssociationMixin<File>;
	declare removeUpdated_by_file: Sequelize.HasManyRemoveAssociationMixin<File, FileId>;
	declare removeUpdated_by_files: Sequelize.HasManyRemoveAssociationsMixin<File, FileId>;
	declare hasUpdated_by_file: Sequelize.HasManyHasAssociationMixin<File, FileId>;
	declare hasUpdated_by_files: Sequelize.HasManyHasAssociationsMixin<File, FileId>;
	declare countUpdated_by_files: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany IncidentFile via created_by
	declare incident_files: IncidentFile[];
	declare getIncident_files: Sequelize.HasManyGetAssociationsMixin<IncidentFile>;
	declare setIncident_files: Sequelize.HasManySetAssociationsMixin<IncidentFile, IncidentFileId>;
	declare addIncident_file: Sequelize.HasManyAddAssociationMixin<IncidentFile, IncidentFileId>;
	declare addIncident_files: Sequelize.HasManyAddAssociationsMixin<IncidentFile, IncidentFileId>;
	declare createIncident_file: Sequelize.HasManyCreateAssociationMixin<IncidentFile>;
	declare removeIncident_file: Sequelize.HasManyRemoveAssociationMixin<IncidentFile, IncidentFileId>;
	declare removeIncident_files: Sequelize.HasManyRemoveAssociationsMixin<IncidentFile, IncidentFileId>;
	declare hasIncident_file: Sequelize.HasManyHasAssociationMixin<IncidentFile, IncidentFileId>;
	declare hasIncident_files: Sequelize.HasManyHasAssociationsMixin<IncidentFile, IncidentFileId>;
	declare countIncident_files: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany IncidentFile via deleted_by
	declare deleted_by_incident_files: IncidentFile[];
	declare getDeleted_by_incident_files: Sequelize.HasManyGetAssociationsMixin<IncidentFile>;
	declare setDeleted_by_incident_files: Sequelize.HasManySetAssociationsMixin<IncidentFile, IncidentFileId>;
	declare addDeleted_by_incident_file: Sequelize.HasManyAddAssociationMixin<IncidentFile, IncidentFileId>;
	declare addDeleted_by_incident_files: Sequelize.HasManyAddAssociationsMixin<IncidentFile, IncidentFileId>;
	declare createDeleted_by_incident_file: Sequelize.HasManyCreateAssociationMixin<IncidentFile>;
	declare removeDeleted_by_incident_file: Sequelize.HasManyRemoveAssociationMixin<IncidentFile, IncidentFileId>;
	declare removeDeleted_by_incident_files: Sequelize.HasManyRemoveAssociationsMixin<IncidentFile, IncidentFileId>;
	declare hasDeleted_by_incident_file: Sequelize.HasManyHasAssociationMixin<IncidentFile, IncidentFileId>;
	declare hasDeleted_by_incident_files: Sequelize.HasManyHasAssociationsMixin<IncidentFile, IncidentFileId>;
	declare countDeleted_by_incident_files: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany IncidentFile via updated_by
	declare updated_by_incident_files: IncidentFile[];
	declare getUpdated_by_incident_files: Sequelize.HasManyGetAssociationsMixin<IncidentFile>;
	declare setUpdated_by_incident_files: Sequelize.HasManySetAssociationsMixin<IncidentFile, IncidentFileId>;
	declare addUpdated_by_incident_file: Sequelize.HasManyAddAssociationMixin<IncidentFile, IncidentFileId>;
	declare addUpdated_by_incident_files: Sequelize.HasManyAddAssociationsMixin<IncidentFile, IncidentFileId>;
	declare createUpdated_by_incident_file: Sequelize.HasManyCreateAssociationMixin<IncidentFile>;
	declare removeUpdated_by_incident_file: Sequelize.HasManyRemoveAssociationMixin<IncidentFile, IncidentFileId>;
	declare removeUpdated_by_incident_files: Sequelize.HasManyRemoveAssociationsMixin<IncidentFile, IncidentFileId>;
	declare hasUpdated_by_incident_file: Sequelize.HasManyHasAssociationMixin<IncidentFile, IncidentFileId>;
	declare hasUpdated_by_incident_files: Sequelize.HasManyHasAssociationsMixin<IncidentFile, IncidentFileId>;
	declare countUpdated_by_incident_files: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany IncidentType via created_by
	declare incident_types: IncidentType[];
	declare getIncident_types: Sequelize.HasManyGetAssociationsMixin<IncidentType>;
	declare setIncident_types: Sequelize.HasManySetAssociationsMixin<IncidentType, IncidentTypeId>;
	declare addIncident_type: Sequelize.HasManyAddAssociationMixin<IncidentType, IncidentTypeId>;
	declare addIncident_types: Sequelize.HasManyAddAssociationsMixin<IncidentType, IncidentTypeId>;
	declare createIncident_type: Sequelize.HasManyCreateAssociationMixin<IncidentType>;
	declare removeIncident_type: Sequelize.HasManyRemoveAssociationMixin<IncidentType, IncidentTypeId>;
	declare removeIncident_types: Sequelize.HasManyRemoveAssociationsMixin<IncidentType, IncidentTypeId>;
	declare hasIncident_type: Sequelize.HasManyHasAssociationMixin<IncidentType, IncidentTypeId>;
	declare hasIncident_types: Sequelize.HasManyHasAssociationsMixin<IncidentType, IncidentTypeId>;
	declare countIncident_types: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany IncidentType via deleted_by
	declare deleted_by_incident_types: IncidentType[];
	declare getDeleted_by_incident_types: Sequelize.HasManyGetAssociationsMixin<IncidentType>;
	declare setDeleted_by_incident_types: Sequelize.HasManySetAssociationsMixin<IncidentType, IncidentTypeId>;
	declare addDeleted_by_incident_type: Sequelize.HasManyAddAssociationMixin<IncidentType, IncidentTypeId>;
	declare addDeleted_by_incident_types: Sequelize.HasManyAddAssociationsMixin<IncidentType, IncidentTypeId>;
	declare createDeleted_by_incident_type: Sequelize.HasManyCreateAssociationMixin<IncidentType>;
	declare removeDeleted_by_incident_type: Sequelize.HasManyRemoveAssociationMixin<IncidentType, IncidentTypeId>;
	declare removeDeleted_by_incident_types: Sequelize.HasManyRemoveAssociationsMixin<IncidentType, IncidentTypeId>;
	declare hasDeleted_by_incident_type: Sequelize.HasManyHasAssociationMixin<IncidentType, IncidentTypeId>;
	declare hasDeleted_by_incident_types: Sequelize.HasManyHasAssociationsMixin<IncidentType, IncidentTypeId>;
	declare countDeleted_by_incident_types: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany IncidentType via updated_by
	declare updated_by_incident_types: IncidentType[];
	declare getUpdated_by_incident_types: Sequelize.HasManyGetAssociationsMixin<IncidentType>;
	declare setUpdated_by_incident_types: Sequelize.HasManySetAssociationsMixin<IncidentType, IncidentTypeId>;
	declare addUpdated_by_incident_type: Sequelize.HasManyAddAssociationMixin<IncidentType, IncidentTypeId>;
	declare addUpdated_by_incident_types: Sequelize.HasManyAddAssociationsMixin<IncidentType, IncidentTypeId>;
	declare createUpdated_by_incident_type: Sequelize.HasManyCreateAssociationMixin<IncidentType>;
	declare removeUpdated_by_incident_type: Sequelize.HasManyRemoveAssociationMixin<IncidentType, IncidentTypeId>;
	declare removeUpdated_by_incident_types: Sequelize.HasManyRemoveAssociationsMixin<IncidentType, IncidentTypeId>;
	declare hasUpdated_by_incident_type: Sequelize.HasManyHasAssociationMixin<IncidentType, IncidentTypeId>;
	declare hasUpdated_by_incident_types: Sequelize.HasManyHasAssociationsMixin<IncidentType, IncidentTypeId>;
	declare countUpdated_by_incident_types: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Incident via created_by
	declare incidents: Incident[];
	declare getIncidents: Sequelize.HasManyGetAssociationsMixin<Incident>;
	declare setIncidents: Sequelize.HasManySetAssociationsMixin<Incident, IncidentId>;
	declare addIncident: Sequelize.HasManyAddAssociationMixin<Incident, IncidentId>;
	declare addIncidents: Sequelize.HasManyAddAssociationsMixin<Incident, IncidentId>;
	declare createIncident: Sequelize.HasManyCreateAssociationMixin<Incident>;
	declare removeIncident: Sequelize.HasManyRemoveAssociationMixin<Incident, IncidentId>;
	declare removeIncidents: Sequelize.HasManyRemoveAssociationsMixin<Incident, IncidentId>;
	declare hasIncident: Sequelize.HasManyHasAssociationMixin<Incident, IncidentId>;
	declare hasIncidents: Sequelize.HasManyHasAssociationsMixin<Incident, IncidentId>;
	declare countIncidents: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Incident via deleted_by
	declare deleted_by_incidents: Incident[];
	declare getDeleted_by_incidents: Sequelize.HasManyGetAssociationsMixin<Incident>;
	declare setDeleted_by_incidents: Sequelize.HasManySetAssociationsMixin<Incident, IncidentId>;
	declare addDeleted_by_incident: Sequelize.HasManyAddAssociationMixin<Incident, IncidentId>;
	declare addDeleted_by_incidents: Sequelize.HasManyAddAssociationsMixin<Incident, IncidentId>;
	declare createDeleted_by_incident: Sequelize.HasManyCreateAssociationMixin<Incident>;
	declare removeDeleted_by_incident: Sequelize.HasManyRemoveAssociationMixin<Incident, IncidentId>;
	declare removeDeleted_by_incidents: Sequelize.HasManyRemoveAssociationsMixin<Incident, IncidentId>;
	declare hasDeleted_by_incident: Sequelize.HasManyHasAssociationMixin<Incident, IncidentId>;
	declare hasDeleted_by_incidents: Sequelize.HasManyHasAssociationsMixin<Incident, IncidentId>;
	declare countDeleted_by_incidents: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Incident via reporter_id
	declare reporter_incidents: Incident[];
	declare getReporter_incidents: Sequelize.HasManyGetAssociationsMixin<Incident>;
	declare setReporter_incidents: Sequelize.HasManySetAssociationsMixin<Incident, IncidentId>;
	declare addReporter_incident: Sequelize.HasManyAddAssociationMixin<Incident, IncidentId>;
	declare addReporter_incidents: Sequelize.HasManyAddAssociationsMixin<Incident, IncidentId>;
	declare createReporter_incident: Sequelize.HasManyCreateAssociationMixin<Incident>;
	declare removeReporter_incident: Sequelize.HasManyRemoveAssociationMixin<Incident, IncidentId>;
	declare removeReporter_incidents: Sequelize.HasManyRemoveAssociationsMixin<Incident, IncidentId>;
	declare hasReporter_incident: Sequelize.HasManyHasAssociationMixin<Incident, IncidentId>;
	declare hasReporter_incidents: Sequelize.HasManyHasAssociationsMixin<Incident, IncidentId>;
	declare countReporter_incidents: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Incident via updated_by
	declare updated_by_incidents: Incident[];
	declare getUpdated_by_incidents: Sequelize.HasManyGetAssociationsMixin<Incident>;
	declare setUpdated_by_incidents: Sequelize.HasManySetAssociationsMixin<Incident, IncidentId>;
	declare addUpdated_by_incident: Sequelize.HasManyAddAssociationMixin<Incident, IncidentId>;
	declare addUpdated_by_incidents: Sequelize.HasManyAddAssociationsMixin<Incident, IncidentId>;
	declare createUpdated_by_incident: Sequelize.HasManyCreateAssociationMixin<Incident>;
	declare removeUpdated_by_incident: Sequelize.HasManyRemoveAssociationMixin<Incident, IncidentId>;
	declare removeUpdated_by_incidents: Sequelize.HasManyRemoveAssociationsMixin<Incident, IncidentId>;
	declare hasUpdated_by_incident: Sequelize.HasManyHasAssociationMixin<Incident, IncidentId>;
	declare hasUpdated_by_incidents: Sequelize.HasManyHasAssociationsMixin<Incident, IncidentId>;
	declare countUpdated_by_incidents: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany NotificationDevice via user_id
	declare notification_devices: NotificationDevice[];
	declare getNotification_devices: Sequelize.HasManyGetAssociationsMixin<NotificationDevice>;
	declare setNotification_devices: Sequelize.HasManySetAssociationsMixin<NotificationDevice, NotificationDeviceId>;
	declare addNotification_device: Sequelize.HasManyAddAssociationMixin<NotificationDevice, NotificationDeviceId>;
	declare addNotification_devices: Sequelize.HasManyAddAssociationsMixin<NotificationDevice, NotificationDeviceId>;
	declare createNotification_device: Sequelize.HasManyCreateAssociationMixin<NotificationDevice>;
	declare removeNotification_device: Sequelize.HasManyRemoveAssociationMixin<NotificationDevice, NotificationDeviceId>;
	declare removeNotification_devices: Sequelize.HasManyRemoveAssociationsMixin<
		NotificationDevice,
		NotificationDeviceId
	>;
	declare hasNotification_device: Sequelize.HasManyHasAssociationMixin<NotificationDevice, NotificationDeviceId>;
	declare hasNotification_devices: Sequelize.HasManyHasAssociationsMixin<NotificationDevice, NotificationDeviceId>;
	declare countNotification_devices: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany NotificationPreference via user_id
	declare notification_preferences: NotificationPreference[];
	declare getNotification_preferences: Sequelize.HasManyGetAssociationsMixin<NotificationPreference>;
	declare setNotification_preferences: Sequelize.HasManySetAssociationsMixin<
		NotificationPreference,
		NotificationPreferenceId
	>;
	declare addNotification_preference: Sequelize.HasManyAddAssociationMixin<
		NotificationPreference,
		NotificationPreferenceId
	>;
	declare addNotification_preferences: Sequelize.HasManyAddAssociationsMixin<
		NotificationPreference,
		NotificationPreferenceId
	>;
	declare createNotification_preference: Sequelize.HasManyCreateAssociationMixin<NotificationPreference>;
	declare removeNotification_preference: Sequelize.HasManyRemoveAssociationMixin<
		NotificationPreference,
		NotificationPreferenceId
	>;
	declare removeNotification_preferences: Sequelize.HasManyRemoveAssociationsMixin<
		NotificationPreference,
		NotificationPreferenceId
	>;
	declare hasNotification_preference: Sequelize.HasManyHasAssociationMixin<
		NotificationPreference,
		NotificationPreferenceId
	>;
	declare hasNotification_preferences: Sequelize.HasManyHasAssociationsMixin<
		NotificationPreference,
		NotificationPreferenceId
	>;
	declare countNotification_preferences: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany NotificationReceipt via user_id
	declare notification_receipts: NotificationReceipt[];
	declare getNotification_receipts: Sequelize.HasManyGetAssociationsMixin<NotificationReceipt>;
	declare setNotification_receipts: Sequelize.HasManySetAssociationsMixin<NotificationReceipt, NotificationReceiptId>;
	declare addNotification_receipt: Sequelize.HasManyAddAssociationMixin<NotificationReceipt, NotificationReceiptId>;
	declare addNotification_receipts: Sequelize.HasManyAddAssociationsMixin<NotificationReceipt, NotificationReceiptId>;
	declare createNotification_receipt: Sequelize.HasManyCreateAssociationMixin<NotificationReceipt>;
	declare removeNotification_receipt: Sequelize.HasManyRemoveAssociationMixin<
		NotificationReceipt,
		NotificationReceiptId
	>;
	declare removeNotification_receipts: Sequelize.HasManyRemoveAssociationsMixin<
		NotificationReceipt,
		NotificationReceiptId
	>;
	declare hasNotification_receipt: Sequelize.HasManyHasAssociationMixin<NotificationReceipt, NotificationReceiptId>;
	declare hasNotification_receipts: Sequelize.HasManyHasAssociationsMixin<NotificationReceipt, NotificationReceiptId>;
	declare countNotification_receipts: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany NotificationTemplate via created_by
	declare notification_templates: NotificationTemplate[];
	declare getNotification_templates: Sequelize.HasManyGetAssociationsMixin<NotificationTemplate>;
	declare setNotification_templates: Sequelize.HasManySetAssociationsMixin<
		NotificationTemplate,
		NotificationTemplateId
	>;
	declare addNotification_template: Sequelize.HasManyAddAssociationMixin<NotificationTemplate, NotificationTemplateId>;
	declare addNotification_templates: Sequelize.HasManyAddAssociationsMixin<
		NotificationTemplate,
		NotificationTemplateId
	>;
	declare createNotification_template: Sequelize.HasManyCreateAssociationMixin<NotificationTemplate>;
	declare removeNotification_template: Sequelize.HasManyRemoveAssociationMixin<
		NotificationTemplate,
		NotificationTemplateId
	>;
	declare removeNotification_templates: Sequelize.HasManyRemoveAssociationsMixin<
		NotificationTemplate,
		NotificationTemplateId
	>;
	declare hasNotification_template: Sequelize.HasManyHasAssociationMixin<NotificationTemplate, NotificationTemplateId>;
	declare hasNotification_templates: Sequelize.HasManyHasAssociationsMixin<
		NotificationTemplate,
		NotificationTemplateId
	>;
	declare countNotification_templates: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany NotificationTemplate via updated_by
	declare updated_by_notification_templates: NotificationTemplate[];
	declare getUpdated_by_notification_templates: Sequelize.HasManyGetAssociationsMixin<NotificationTemplate>;
	declare setUpdated_by_notification_templates: Sequelize.HasManySetAssociationsMixin<
		NotificationTemplate,
		NotificationTemplateId
	>;
	declare addUpdated_by_notification_template: Sequelize.HasManyAddAssociationMixin<
		NotificationTemplate,
		NotificationTemplateId
	>;
	declare addUpdated_by_notification_templates: Sequelize.HasManyAddAssociationsMixin<
		NotificationTemplate,
		NotificationTemplateId
	>;
	declare createUpdated_by_notification_template: Sequelize.HasManyCreateAssociationMixin<NotificationTemplate>;
	declare removeUpdated_by_notification_template: Sequelize.HasManyRemoveAssociationMixin<
		NotificationTemplate,
		NotificationTemplateId
	>;
	declare removeUpdated_by_notification_templates: Sequelize.HasManyRemoveAssociationsMixin<
		NotificationTemplate,
		NotificationTemplateId
	>;
	declare hasUpdated_by_notification_template: Sequelize.HasManyHasAssociationMixin<
		NotificationTemplate,
		NotificationTemplateId
	>;
	declare hasUpdated_by_notification_templates: Sequelize.HasManyHasAssociationsMixin<
		NotificationTemplate,
		NotificationTemplateId
	>;
	declare countUpdated_by_notification_templates: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany PasswordResetToken via user_id
	declare password_reset_tokens: PasswordResetToken[];
	declare getPassword_reset_tokens: Sequelize.HasManyGetAssociationsMixin<PasswordResetToken>;
	declare setPassword_reset_tokens: Sequelize.HasManySetAssociationsMixin<PasswordResetToken, PasswordResetTokenId>;
	declare addPassword_reset_token: Sequelize.HasManyAddAssociationMixin<PasswordResetToken, PasswordResetTokenId>;
	declare addPassword_reset_tokens: Sequelize.HasManyAddAssociationsMixin<PasswordResetToken, PasswordResetTokenId>;
	declare createPassword_reset_token: Sequelize.HasManyCreateAssociationMixin<PasswordResetToken>;
	declare removePassword_reset_token: Sequelize.HasManyRemoveAssociationMixin<PasswordResetToken, PasswordResetTokenId>;
	declare removePassword_reset_tokens: Sequelize.HasManyRemoveAssociationsMixin<
		PasswordResetToken,
		PasswordResetTokenId
	>;
	declare hasPassword_reset_token: Sequelize.HasManyHasAssociationMixin<PasswordResetToken, PasswordResetTokenId>;
	declare hasPassword_reset_tokens: Sequelize.HasManyHasAssociationsMixin<PasswordResetToken, PasswordResetTokenId>;
	declare countPassword_reset_tokens: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Permission via created_by
	declare permissions: Permission[];
	declare getPermissions: Sequelize.HasManyGetAssociationsMixin<Permission>;
	declare setPermissions: Sequelize.HasManySetAssociationsMixin<Permission, PermissionId>;
	declare addPermission: Sequelize.HasManyAddAssociationMixin<Permission, PermissionId>;
	declare addPermissions: Sequelize.HasManyAddAssociationsMixin<Permission, PermissionId>;
	declare createPermission: Sequelize.HasManyCreateAssociationMixin<Permission>;
	declare removePermission: Sequelize.HasManyRemoveAssociationMixin<Permission, PermissionId>;
	declare removePermissions: Sequelize.HasManyRemoveAssociationsMixin<Permission, PermissionId>;
	declare hasPermission: Sequelize.HasManyHasAssociationMixin<Permission, PermissionId>;
	declare hasPermissions: Sequelize.HasManyHasAssociationsMixin<Permission, PermissionId>;
	declare countPermissions: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Permission via updated_by
	declare updated_by_permissions: Permission[];
	declare getUpdated_by_permissions: Sequelize.HasManyGetAssociationsMixin<Permission>;
	declare setUpdated_by_permissions: Sequelize.HasManySetAssociationsMixin<Permission, PermissionId>;
	declare addUpdated_by_permission: Sequelize.HasManyAddAssociationMixin<Permission, PermissionId>;
	declare addUpdated_by_permissions: Sequelize.HasManyAddAssociationsMixin<Permission, PermissionId>;
	declare createUpdated_by_permission: Sequelize.HasManyCreateAssociationMixin<Permission>;
	declare removeUpdated_by_permission: Sequelize.HasManyRemoveAssociationMixin<Permission, PermissionId>;
	declare removeUpdated_by_permissions: Sequelize.HasManyRemoveAssociationsMixin<Permission, PermissionId>;
	declare hasUpdated_by_permission: Sequelize.HasManyHasAssociationMixin<Permission, PermissionId>;
	declare hasUpdated_by_permissions: Sequelize.HasManyHasAssociationsMixin<Permission, PermissionId>;
	declare countUpdated_by_permissions: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Post via author_id
	declare posts: Post[];
	declare getPosts: Sequelize.HasManyGetAssociationsMixin<Post>;
	declare setPosts: Sequelize.HasManySetAssociationsMixin<Post, PostId>;
	declare addPost: Sequelize.HasManyAddAssociationMixin<Post, PostId>;
	declare addPosts: Sequelize.HasManyAddAssociationsMixin<Post, PostId>;
	declare createPost: Sequelize.HasManyCreateAssociationMixin<Post>;
	declare removePost: Sequelize.HasManyRemoveAssociationMixin<Post, PostId>;
	declare removePosts: Sequelize.HasManyRemoveAssociationsMixin<Post, PostId>;
	declare hasPost: Sequelize.HasManyHasAssociationMixin<Post, PostId>;
	declare hasPosts: Sequelize.HasManyHasAssociationsMixin<Post, PostId>;
	declare countPosts: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Post via created_by
	declare created_by_posts: Post[];
	declare getCreated_by_posts: Sequelize.HasManyGetAssociationsMixin<Post>;
	declare setCreated_by_posts: Sequelize.HasManySetAssociationsMixin<Post, PostId>;
	declare addCreated_by_post: Sequelize.HasManyAddAssociationMixin<Post, PostId>;
	declare addCreated_by_posts: Sequelize.HasManyAddAssociationsMixin<Post, PostId>;
	declare createCreated_by_post: Sequelize.HasManyCreateAssociationMixin<Post>;
	declare removeCreated_by_post: Sequelize.HasManyRemoveAssociationMixin<Post, PostId>;
	declare removeCreated_by_posts: Sequelize.HasManyRemoveAssociationsMixin<Post, PostId>;
	declare hasCreated_by_post: Sequelize.HasManyHasAssociationMixin<Post, PostId>;
	declare hasCreated_by_posts: Sequelize.HasManyHasAssociationsMixin<Post, PostId>;
	declare countCreated_by_posts: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Post via deleted_by
	declare deleted_by_posts: Post[];
	declare getDeleted_by_posts: Sequelize.HasManyGetAssociationsMixin<Post>;
	declare setDeleted_by_posts: Sequelize.HasManySetAssociationsMixin<Post, PostId>;
	declare addDeleted_by_post: Sequelize.HasManyAddAssociationMixin<Post, PostId>;
	declare addDeleted_by_posts: Sequelize.HasManyAddAssociationsMixin<Post, PostId>;
	declare createDeleted_by_post: Sequelize.HasManyCreateAssociationMixin<Post>;
	declare removeDeleted_by_post: Sequelize.HasManyRemoveAssociationMixin<Post, PostId>;
	declare removeDeleted_by_posts: Sequelize.HasManyRemoveAssociationsMixin<Post, PostId>;
	declare hasDeleted_by_post: Sequelize.HasManyHasAssociationMixin<Post, PostId>;
	declare hasDeleted_by_posts: Sequelize.HasManyHasAssociationsMixin<Post, PostId>;
	declare countDeleted_by_posts: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Post via updated_by
	declare updated_by_posts: Post[];
	declare getUpdated_by_posts: Sequelize.HasManyGetAssociationsMixin<Post>;
	declare setUpdated_by_posts: Sequelize.HasManySetAssociationsMixin<Post, PostId>;
	declare addUpdated_by_post: Sequelize.HasManyAddAssociationMixin<Post, PostId>;
	declare addUpdated_by_posts: Sequelize.HasManyAddAssociationsMixin<Post, PostId>;
	declare createUpdated_by_post: Sequelize.HasManyCreateAssociationMixin<Post>;
	declare removeUpdated_by_post: Sequelize.HasManyRemoveAssociationMixin<Post, PostId>;
	declare removeUpdated_by_posts: Sequelize.HasManyRemoveAssociationsMixin<Post, PostId>;
	declare hasUpdated_by_post: Sequelize.HasManyHasAssociationMixin<Post, PostId>;
	declare hasUpdated_by_posts: Sequelize.HasManyHasAssociationsMixin<Post, PostId>;
	declare countUpdated_by_posts: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany ResidentDocument via created_by
	declare resident_documents: ResidentDocument[];
	declare getResident_documents: Sequelize.HasManyGetAssociationsMixin<ResidentDocument>;
	declare setResident_documents: Sequelize.HasManySetAssociationsMixin<ResidentDocument, ResidentDocumentId>;
	declare addResident_document: Sequelize.HasManyAddAssociationMixin<ResidentDocument, ResidentDocumentId>;
	declare addResident_documents: Sequelize.HasManyAddAssociationsMixin<ResidentDocument, ResidentDocumentId>;
	declare createResident_document: Sequelize.HasManyCreateAssociationMixin<ResidentDocument>;
	declare removeResident_document: Sequelize.HasManyRemoveAssociationMixin<ResidentDocument, ResidentDocumentId>;
	declare removeResident_documents: Sequelize.HasManyRemoveAssociationsMixin<ResidentDocument, ResidentDocumentId>;
	declare hasResident_document: Sequelize.HasManyHasAssociationMixin<ResidentDocument, ResidentDocumentId>;
	declare hasResident_documents: Sequelize.HasManyHasAssociationsMixin<ResidentDocument, ResidentDocumentId>;
	declare countResident_documents: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany ResidentDocument via deleted_by
	declare deleted_by_resident_documents: ResidentDocument[];
	declare getDeleted_by_resident_documents: Sequelize.HasManyGetAssociationsMixin<ResidentDocument>;
	declare setDeleted_by_resident_documents: Sequelize.HasManySetAssociationsMixin<ResidentDocument, ResidentDocumentId>;
	declare addDeleted_by_resident_document: Sequelize.HasManyAddAssociationMixin<ResidentDocument, ResidentDocumentId>;
	declare addDeleted_by_resident_documents: Sequelize.HasManyAddAssociationsMixin<ResidentDocument, ResidentDocumentId>;
	declare createDeleted_by_resident_document: Sequelize.HasManyCreateAssociationMixin<ResidentDocument>;
	declare removeDeleted_by_resident_document: Sequelize.HasManyRemoveAssociationMixin<
		ResidentDocument,
		ResidentDocumentId
	>;
	declare removeDeleted_by_resident_documents: Sequelize.HasManyRemoveAssociationsMixin<
		ResidentDocument,
		ResidentDocumentId
	>;
	declare hasDeleted_by_resident_document: Sequelize.HasManyHasAssociationMixin<ResidentDocument, ResidentDocumentId>;
	declare hasDeleted_by_resident_documents: Sequelize.HasManyHasAssociationsMixin<ResidentDocument, ResidentDocumentId>;
	declare countDeleted_by_resident_documents: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany ResidentDocument via updated_by
	declare updated_by_resident_documents: ResidentDocument[];
	declare getUpdated_by_resident_documents: Sequelize.HasManyGetAssociationsMixin<ResidentDocument>;
	declare setUpdated_by_resident_documents: Sequelize.HasManySetAssociationsMixin<ResidentDocument, ResidentDocumentId>;
	declare addUpdated_by_resident_document: Sequelize.HasManyAddAssociationMixin<ResidentDocument, ResidentDocumentId>;
	declare addUpdated_by_resident_documents: Sequelize.HasManyAddAssociationsMixin<ResidentDocument, ResidentDocumentId>;
	declare createUpdated_by_resident_document: Sequelize.HasManyCreateAssociationMixin<ResidentDocument>;
	declare removeUpdated_by_resident_document: Sequelize.HasManyRemoveAssociationMixin<
		ResidentDocument,
		ResidentDocumentId
	>;
	declare removeUpdated_by_resident_documents: Sequelize.HasManyRemoveAssociationsMixin<
		ResidentDocument,
		ResidentDocumentId
	>;
	declare hasUpdated_by_resident_document: Sequelize.HasManyHasAssociationMixin<ResidentDocument, ResidentDocumentId>;
	declare hasUpdated_by_resident_documents: Sequelize.HasManyHasAssociationsMixin<ResidentDocument, ResidentDocumentId>;
	declare countUpdated_by_resident_documents: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany ResidentDocument via verified_by
	declare verified_by_resident_documents: ResidentDocument[];
	declare getVerified_by_resident_documents: Sequelize.HasManyGetAssociationsMixin<ResidentDocument>;
	declare setVerified_by_resident_documents: Sequelize.HasManySetAssociationsMixin<
		ResidentDocument,
		ResidentDocumentId
	>;
	declare addVerified_by_resident_document: Sequelize.HasManyAddAssociationMixin<ResidentDocument, ResidentDocumentId>;
	declare addVerified_by_resident_documents: Sequelize.HasManyAddAssociationsMixin<
		ResidentDocument,
		ResidentDocumentId
	>;
	declare createVerified_by_resident_document: Sequelize.HasManyCreateAssociationMixin<ResidentDocument>;
	declare removeVerified_by_resident_document: Sequelize.HasManyRemoveAssociationMixin<
		ResidentDocument,
		ResidentDocumentId
	>;
	declare removeVerified_by_resident_documents: Sequelize.HasManyRemoveAssociationsMixin<
		ResidentDocument,
		ResidentDocumentId
	>;
	declare hasVerified_by_resident_document: Sequelize.HasManyHasAssociationMixin<ResidentDocument, ResidentDocumentId>;
	declare hasVerified_by_resident_documents: Sequelize.HasManyHasAssociationsMixin<
		ResidentDocument,
		ResidentDocumentId
	>;
	declare countVerified_by_resident_documents: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany ResidentEvent via created_by
	declare resident_events: ResidentEvent[];
	declare getResident_events: Sequelize.HasManyGetAssociationsMixin<ResidentEvent>;
	declare setResident_events: Sequelize.HasManySetAssociationsMixin<ResidentEvent, ResidentEventId>;
	declare addResident_event: Sequelize.HasManyAddAssociationMixin<ResidentEvent, ResidentEventId>;
	declare addResident_events: Sequelize.HasManyAddAssociationsMixin<ResidentEvent, ResidentEventId>;
	declare createResident_event: Sequelize.HasManyCreateAssociationMixin<ResidentEvent>;
	declare removeResident_event: Sequelize.HasManyRemoveAssociationMixin<ResidentEvent, ResidentEventId>;
	declare removeResident_events: Sequelize.HasManyRemoveAssociationsMixin<ResidentEvent, ResidentEventId>;
	declare hasResident_event: Sequelize.HasManyHasAssociationMixin<ResidentEvent, ResidentEventId>;
	declare hasResident_events: Sequelize.HasManyHasAssociationsMixin<ResidentEvent, ResidentEventId>;
	declare countResident_events: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany ResidentStay via created_by
	declare resident_stays: ResidentStay[];
	declare getResident_stays: Sequelize.HasManyGetAssociationsMixin<ResidentStay>;
	declare setResident_stays: Sequelize.HasManySetAssociationsMixin<ResidentStay, ResidentStayId>;
	declare addResident_stay: Sequelize.HasManyAddAssociationMixin<ResidentStay, ResidentStayId>;
	declare addResident_stays: Sequelize.HasManyAddAssociationsMixin<ResidentStay, ResidentStayId>;
	declare createResident_stay: Sequelize.HasManyCreateAssociationMixin<ResidentStay>;
	declare removeResident_stay: Sequelize.HasManyRemoveAssociationMixin<ResidentStay, ResidentStayId>;
	declare removeResident_stays: Sequelize.HasManyRemoveAssociationsMixin<ResidentStay, ResidentStayId>;
	declare hasResident_stay: Sequelize.HasManyHasAssociationMixin<ResidentStay, ResidentStayId>;
	declare hasResident_stays: Sequelize.HasManyHasAssociationsMixin<ResidentStay, ResidentStayId>;
	declare countResident_stays: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany ResidentStay via updated_by
	declare updated_by_resident_stays: ResidentStay[];
	declare getUpdated_by_resident_stays: Sequelize.HasManyGetAssociationsMixin<ResidentStay>;
	declare setUpdated_by_resident_stays: Sequelize.HasManySetAssociationsMixin<ResidentStay, ResidentStayId>;
	declare addUpdated_by_resident_stay: Sequelize.HasManyAddAssociationMixin<ResidentStay, ResidentStayId>;
	declare addUpdated_by_resident_stays: Sequelize.HasManyAddAssociationsMixin<ResidentStay, ResidentStayId>;
	declare createUpdated_by_resident_stay: Sequelize.HasManyCreateAssociationMixin<ResidentStay>;
	declare removeUpdated_by_resident_stay: Sequelize.HasManyRemoveAssociationMixin<ResidentStay, ResidentStayId>;
	declare removeUpdated_by_resident_stays: Sequelize.HasManyRemoveAssociationsMixin<ResidentStay, ResidentStayId>;
	declare hasUpdated_by_resident_stay: Sequelize.HasManyHasAssociationMixin<ResidentStay, ResidentStayId>;
	declare hasUpdated_by_resident_stays: Sequelize.HasManyHasAssociationsMixin<ResidentStay, ResidentStayId>;
	declare countUpdated_by_resident_stays: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Resident via created_by
	declare residents: Resident[];
	declare getResidents: Sequelize.HasManyGetAssociationsMixin<Resident>;
	declare setResidents: Sequelize.HasManySetAssociationsMixin<Resident, ResidentId>;
	declare addResident: Sequelize.HasManyAddAssociationMixin<Resident, ResidentId>;
	declare addResidents: Sequelize.HasManyAddAssociationsMixin<Resident, ResidentId>;
	declare createResident: Sequelize.HasManyCreateAssociationMixin<Resident>;
	declare removeResident: Sequelize.HasManyRemoveAssociationMixin<Resident, ResidentId>;
	declare removeResidents: Sequelize.HasManyRemoveAssociationsMixin<Resident, ResidentId>;
	declare hasResident: Sequelize.HasManyHasAssociationMixin<Resident, ResidentId>;
	declare hasResidents: Sequelize.HasManyHasAssociationsMixin<Resident, ResidentId>;
	declare countResidents: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Resident via deleted_by
	declare deleted_by_residents: Resident[];
	declare getDeleted_by_residents: Sequelize.HasManyGetAssociationsMixin<Resident>;
	declare setDeleted_by_residents: Sequelize.HasManySetAssociationsMixin<Resident, ResidentId>;
	declare addDeleted_by_resident: Sequelize.HasManyAddAssociationMixin<Resident, ResidentId>;
	declare addDeleted_by_residents: Sequelize.HasManyAddAssociationsMixin<Resident, ResidentId>;
	declare createDeleted_by_resident: Sequelize.HasManyCreateAssociationMixin<Resident>;
	declare removeDeleted_by_resident: Sequelize.HasManyRemoveAssociationMixin<Resident, ResidentId>;
	declare removeDeleted_by_residents: Sequelize.HasManyRemoveAssociationsMixin<Resident, ResidentId>;
	declare hasDeleted_by_resident: Sequelize.HasManyHasAssociationMixin<Resident, ResidentId>;
	declare hasDeleted_by_residents: Sequelize.HasManyHasAssociationsMixin<Resident, ResidentId>;
	declare countDeleted_by_residents: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Resident via updated_by
	declare updated_by_residents: Resident[];
	declare getUpdated_by_residents: Sequelize.HasManyGetAssociationsMixin<Resident>;
	declare setUpdated_by_residents: Sequelize.HasManySetAssociationsMixin<Resident, ResidentId>;
	declare addUpdated_by_resident: Sequelize.HasManyAddAssociationMixin<Resident, ResidentId>;
	declare addUpdated_by_residents: Sequelize.HasManyAddAssociationsMixin<Resident, ResidentId>;
	declare createUpdated_by_resident: Sequelize.HasManyCreateAssociationMixin<Resident>;
	declare removeUpdated_by_resident: Sequelize.HasManyRemoveAssociationMixin<Resident, ResidentId>;
	declare removeUpdated_by_residents: Sequelize.HasManyRemoveAssociationsMixin<Resident, ResidentId>;
	declare hasUpdated_by_resident: Sequelize.HasManyHasAssociationMixin<Resident, ResidentId>;
	declare hasUpdated_by_residents: Sequelize.HasManyHasAssociationsMixin<Resident, ResidentId>;
	declare countUpdated_by_residents: Sequelize.HasManyCountAssociationsMixin;
	// User hasOne Resident via user_id
	declare user_resident: Resident;
	declare getUser_resident: Sequelize.HasOneGetAssociationMixin<Resident>;
	declare setUser_resident: Sequelize.HasOneSetAssociationMixin<Resident, ResidentId>;
	declare createUser_resident: Sequelize.HasOneCreateAssociationMixin<Resident>;
	// User hasMany RolePermission via created_by
	declare role_permissions: RolePermission[];
	declare getRole_permissions: Sequelize.HasManyGetAssociationsMixin<RolePermission>;
	declare setRole_permissions: Sequelize.HasManySetAssociationsMixin<RolePermission, RolePermissionId>;
	declare addRole_permission: Sequelize.HasManyAddAssociationMixin<RolePermission, RolePermissionId>;
	declare addRole_permissions: Sequelize.HasManyAddAssociationsMixin<RolePermission, RolePermissionId>;
	declare createRole_permission: Sequelize.HasManyCreateAssociationMixin<RolePermission>;
	declare removeRole_permission: Sequelize.HasManyRemoveAssociationMixin<RolePermission, RolePermissionId>;
	declare removeRole_permissions: Sequelize.HasManyRemoveAssociationsMixin<RolePermission, RolePermissionId>;
	declare hasRole_permission: Sequelize.HasManyHasAssociationMixin<RolePermission, RolePermissionId>;
	declare hasRole_permissions: Sequelize.HasManyHasAssociationsMixin<RolePermission, RolePermissionId>;
	declare countRole_permissions: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany RolePermission via updated_by
	declare updated_by_role_permissions: RolePermission[];
	declare getUpdated_by_role_permissions: Sequelize.HasManyGetAssociationsMixin<RolePermission>;
	declare setUpdated_by_role_permissions: Sequelize.HasManySetAssociationsMixin<RolePermission, RolePermissionId>;
	declare addUpdated_by_role_permission: Sequelize.HasManyAddAssociationMixin<RolePermission, RolePermissionId>;
	declare addUpdated_by_role_permissions: Sequelize.HasManyAddAssociationsMixin<RolePermission, RolePermissionId>;
	declare createUpdated_by_role_permission: Sequelize.HasManyCreateAssociationMixin<RolePermission>;
	declare removeUpdated_by_role_permission: Sequelize.HasManyRemoveAssociationMixin<RolePermission, RolePermissionId>;
	declare removeUpdated_by_role_permissions: Sequelize.HasManyRemoveAssociationsMixin<RolePermission, RolePermissionId>;
	declare hasUpdated_by_role_permission: Sequelize.HasManyHasAssociationMixin<RolePermission, RolePermissionId>;
	declare hasUpdated_by_role_permissions: Sequelize.HasManyHasAssociationsMixin<RolePermission, RolePermissionId>;
	declare countUpdated_by_role_permissions: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Role via created_by
	declare roles: Role[];
	declare getRoles: Sequelize.HasManyGetAssociationsMixin<Role>;
	declare setRoles: Sequelize.HasManySetAssociationsMixin<Role, RoleId>;
	declare addRole: Sequelize.HasManyAddAssociationMixin<Role, RoleId>;
	declare addRoles: Sequelize.HasManyAddAssociationsMixin<Role, RoleId>;
	declare createRole: Sequelize.HasManyCreateAssociationMixin<Role>;
	declare removeRole: Sequelize.HasManyRemoveAssociationMixin<Role, RoleId>;
	declare removeRoles: Sequelize.HasManyRemoveAssociationsMixin<Role, RoleId>;
	declare hasRole: Sequelize.HasManyHasAssociationMixin<Role, RoleId>;
	declare hasRoles: Sequelize.HasManyHasAssociationsMixin<Role, RoleId>;
	declare countRoles: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Role via updated_by
	declare updated_by_roles: Role[];
	declare getUpdated_by_roles: Sequelize.HasManyGetAssociationsMixin<Role>;
	declare setUpdated_by_roles: Sequelize.HasManySetAssociationsMixin<Role, RoleId>;
	declare addUpdated_by_role: Sequelize.HasManyAddAssociationMixin<Role, RoleId>;
	declare addUpdated_by_roles: Sequelize.HasManyAddAssociationsMixin<Role, RoleId>;
	declare createUpdated_by_role: Sequelize.HasManyCreateAssociationMixin<Role>;
	declare removeUpdated_by_role: Sequelize.HasManyRemoveAssociationMixin<Role, RoleId>;
	declare removeUpdated_by_roles: Sequelize.HasManyRemoveAssociationsMixin<Role, RoleId>;
	declare hasUpdated_by_role: Sequelize.HasManyHasAssociationMixin<Role, RoleId>;
	declare hasUpdated_by_roles: Sequelize.HasManyHasAssociationsMixin<Role, RoleId>;
	declare countUpdated_by_roles: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Room via created_by
	declare rooms: Room[];
	declare getRooms: Sequelize.HasManyGetAssociationsMixin<Room>;
	declare setRooms: Sequelize.HasManySetAssociationsMixin<Room, RoomId>;
	declare addRoom: Sequelize.HasManyAddAssociationMixin<Room, RoomId>;
	declare addRooms: Sequelize.HasManyAddAssociationsMixin<Room, RoomId>;
	declare createRoom: Sequelize.HasManyCreateAssociationMixin<Room>;
	declare removeRoom: Sequelize.HasManyRemoveAssociationMixin<Room, RoomId>;
	declare removeRooms: Sequelize.HasManyRemoveAssociationsMixin<Room, RoomId>;
	declare hasRoom: Sequelize.HasManyHasAssociationMixin<Room, RoomId>;
	declare hasRooms: Sequelize.HasManyHasAssociationsMixin<Room, RoomId>;
	declare countRooms: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Room via deleted_by
	declare deleted_by_rooms: Room[];
	declare getDeleted_by_rooms: Sequelize.HasManyGetAssociationsMixin<Room>;
	declare setDeleted_by_rooms: Sequelize.HasManySetAssociationsMixin<Room, RoomId>;
	declare addDeleted_by_room: Sequelize.HasManyAddAssociationMixin<Room, RoomId>;
	declare addDeleted_by_rooms: Sequelize.HasManyAddAssociationsMixin<Room, RoomId>;
	declare createDeleted_by_room: Sequelize.HasManyCreateAssociationMixin<Room>;
	declare removeDeleted_by_room: Sequelize.HasManyRemoveAssociationMixin<Room, RoomId>;
	declare removeDeleted_by_rooms: Sequelize.HasManyRemoveAssociationsMixin<Room, RoomId>;
	declare hasDeleted_by_room: Sequelize.HasManyHasAssociationMixin<Room, RoomId>;
	declare hasDeleted_by_rooms: Sequelize.HasManyHasAssociationsMixin<Room, RoomId>;
	declare countDeleted_by_rooms: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Room via updated_by
	declare updated_by_rooms: Room[];
	declare getUpdated_by_rooms: Sequelize.HasManyGetAssociationsMixin<Room>;
	declare setUpdated_by_rooms: Sequelize.HasManySetAssociationsMixin<Room, RoomId>;
	declare addUpdated_by_room: Sequelize.HasManyAddAssociationMixin<Room, RoomId>;
	declare addUpdated_by_rooms: Sequelize.HasManyAddAssociationsMixin<Room, RoomId>;
	declare createUpdated_by_room: Sequelize.HasManyCreateAssociationMixin<Room>;
	declare removeUpdated_by_room: Sequelize.HasManyRemoveAssociationMixin<Room, RoomId>;
	declare removeUpdated_by_rooms: Sequelize.HasManyRemoveAssociationsMixin<Room, RoomId>;
	declare hasUpdated_by_room: Sequelize.HasManyHasAssociationMixin<Room, RoomId>;
	declare hasUpdated_by_rooms: Sequelize.HasManyHasAssociationsMixin<Room, RoomId>;
	declare countUpdated_by_rooms: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Technician via created_by
	declare technicians: Technician[];
	declare getTechnicians: Sequelize.HasManyGetAssociationsMixin<Technician>;
	declare setTechnicians: Sequelize.HasManySetAssociationsMixin<Technician, TechnicianId>;
	declare addTechnician: Sequelize.HasManyAddAssociationMixin<Technician, TechnicianId>;
	declare addTechnicians: Sequelize.HasManyAddAssociationsMixin<Technician, TechnicianId>;
	declare createTechnician: Sequelize.HasManyCreateAssociationMixin<Technician>;
	declare removeTechnician: Sequelize.HasManyRemoveAssociationMixin<Technician, TechnicianId>;
	declare removeTechnicians: Sequelize.HasManyRemoveAssociationsMixin<Technician, TechnicianId>;
	declare hasTechnician: Sequelize.HasManyHasAssociationMixin<Technician, TechnicianId>;
	declare hasTechnicians: Sequelize.HasManyHasAssociationsMixin<Technician, TechnicianId>;
	declare countTechnicians: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Technician via deleted_by
	declare deleted_by_technicians: Technician[];
	declare getDeleted_by_technicians: Sequelize.HasManyGetAssociationsMixin<Technician>;
	declare setDeleted_by_technicians: Sequelize.HasManySetAssociationsMixin<Technician, TechnicianId>;
	declare addDeleted_by_technician: Sequelize.HasManyAddAssociationMixin<Technician, TechnicianId>;
	declare addDeleted_by_technicians: Sequelize.HasManyAddAssociationsMixin<Technician, TechnicianId>;
	declare createDeleted_by_technician: Sequelize.HasManyCreateAssociationMixin<Technician>;
	declare removeDeleted_by_technician: Sequelize.HasManyRemoveAssociationMixin<Technician, TechnicianId>;
	declare removeDeleted_by_technicians: Sequelize.HasManyRemoveAssociationsMixin<Technician, TechnicianId>;
	declare hasDeleted_by_technician: Sequelize.HasManyHasAssociationMixin<Technician, TechnicianId>;
	declare hasDeleted_by_technicians: Sequelize.HasManyHasAssociationsMixin<Technician, TechnicianId>;
	declare countDeleted_by_technicians: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Technician via updated_by
	declare updated_by_technicians: Technician[];
	declare getUpdated_by_technicians: Sequelize.HasManyGetAssociationsMixin<Technician>;
	declare setUpdated_by_technicians: Sequelize.HasManySetAssociationsMixin<Technician, TechnicianId>;
	declare addUpdated_by_technician: Sequelize.HasManyAddAssociationMixin<Technician, TechnicianId>;
	declare addUpdated_by_technicians: Sequelize.HasManyAddAssociationsMixin<Technician, TechnicianId>;
	declare createUpdated_by_technician: Sequelize.HasManyCreateAssociationMixin<Technician>;
	declare removeUpdated_by_technician: Sequelize.HasManyRemoveAssociationMixin<Technician, TechnicianId>;
	declare removeUpdated_by_technicians: Sequelize.HasManyRemoveAssociationsMixin<Technician, TechnicianId>;
	declare hasUpdated_by_technician: Sequelize.HasManyHasAssociationMixin<Technician, TechnicianId>;
	declare hasUpdated_by_technicians: Sequelize.HasManyHasAssociationsMixin<Technician, TechnicianId>;
	declare countUpdated_by_technicians: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany Technician via user_id
	declare user_technicians: Technician[];
	declare getUser_technicians: Sequelize.HasManyGetAssociationsMixin<Technician>;
	declare setUser_technicians: Sequelize.HasManySetAssociationsMixin<Technician, TechnicianId>;
	declare addUser_technician: Sequelize.HasManyAddAssociationMixin<Technician, TechnicianId>;
	declare addUser_technicians: Sequelize.HasManyAddAssociationsMixin<Technician, TechnicianId>;
	declare createUser_technician: Sequelize.HasManyCreateAssociationMixin<Technician>;
	declare removeUser_technician: Sequelize.HasManyRemoveAssociationMixin<Technician, TechnicianId>;
	declare removeUser_technicians: Sequelize.HasManyRemoveAssociationsMixin<Technician, TechnicianId>;
	declare hasUser_technician: Sequelize.HasManyHasAssociationMixin<Technician, TechnicianId>;
	declare hasUser_technicians: Sequelize.HasManyHasAssociationsMixin<Technician, TechnicianId>;
	declare countUser_technicians: Sequelize.HasManyCountAssociationsMixin;
	// User hasOne UserAuth via user_id
	declare user_auth: UserAuth;
	declare getUser_auth: Sequelize.HasOneGetAssociationMixin<UserAuth>;
	declare setUser_auth: Sequelize.HasOneSetAssociationMixin<UserAuth, UserAuthId>;
	declare createUser_auth: Sequelize.HasOneCreateAssociationMixin<UserAuth>;
	// User hasMany UserPasswordHistory via changed_by
	declare user_password_histories: UserPasswordHistory[];
	declare getUser_password_histories: Sequelize.HasManyGetAssociationsMixin<UserPasswordHistory>;
	declare setUser_password_histories: Sequelize.HasManySetAssociationsMixin<UserPasswordHistory, UserPasswordHistoryId>;
	declare addUser_password_history: Sequelize.HasManyAddAssociationMixin<UserPasswordHistory, UserPasswordHistoryId>;
	declare addUser_password_histories: Sequelize.HasManyAddAssociationsMixin<UserPasswordHistory, UserPasswordHistoryId>;
	declare createUser_password_history: Sequelize.HasManyCreateAssociationMixin<UserPasswordHistory>;
	declare removeUser_password_history: Sequelize.HasManyRemoveAssociationMixin<
		UserPasswordHistory,
		UserPasswordHistoryId
	>;
	declare removeUser_password_histories: Sequelize.HasManyRemoveAssociationsMixin<
		UserPasswordHistory,
		UserPasswordHistoryId
	>;
	declare hasUser_password_history: Sequelize.HasManyHasAssociationMixin<UserPasswordHistory, UserPasswordHistoryId>;
	declare hasUser_password_histories: Sequelize.HasManyHasAssociationsMixin<UserPasswordHistory, UserPasswordHistoryId>;
	declare countUser_password_histories: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany UserPasswordHistory via user_id
	declare user_user_password_histories: UserPasswordHistory[];
	declare getUser_user_password_histories: Sequelize.HasManyGetAssociationsMixin<UserPasswordHistory>;
	declare setUser_user_password_histories: Sequelize.HasManySetAssociationsMixin<
		UserPasswordHistory,
		UserPasswordHistoryId
	>;
	declare addUser_user_password_history: Sequelize.HasManyAddAssociationMixin<
		UserPasswordHistory,
		UserPasswordHistoryId
	>;
	declare addUser_user_password_histories: Sequelize.HasManyAddAssociationsMixin<
		UserPasswordHistory,
		UserPasswordHistoryId
	>;
	declare createUser_user_password_history: Sequelize.HasManyCreateAssociationMixin<UserPasswordHistory>;
	declare removeUser_user_password_history: Sequelize.HasManyRemoveAssociationMixin<
		UserPasswordHistory,
		UserPasswordHistoryId
	>;
	declare removeUser_user_password_histories: Sequelize.HasManyRemoveAssociationsMixin<
		UserPasswordHistory,
		UserPasswordHistoryId
	>;
	declare hasUser_user_password_history: Sequelize.HasManyHasAssociationMixin<
		UserPasswordHistory,
		UserPasswordHistoryId
	>;
	declare hasUser_user_password_histories: Sequelize.HasManyHasAssociationsMixin<
		UserPasswordHistory,
		UserPasswordHistoryId
	>;
	declare countUser_user_password_histories: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany UserRole via assigned_by
	declare user_roles: UserRole[];
	declare getUser_roles: Sequelize.HasManyGetAssociationsMixin<UserRole>;
	declare setUser_roles: Sequelize.HasManySetAssociationsMixin<UserRole, UserRoleId>;
	declare addUser_role: Sequelize.HasManyAddAssociationMixin<UserRole, UserRoleId>;
	declare addUser_roles: Sequelize.HasManyAddAssociationsMixin<UserRole, UserRoleId>;
	declare createUser_role: Sequelize.HasManyCreateAssociationMixin<UserRole>;
	declare removeUser_role: Sequelize.HasManyRemoveAssociationMixin<UserRole, UserRoleId>;
	declare removeUser_roles: Sequelize.HasManyRemoveAssociationsMixin<UserRole, UserRoleId>;
	declare hasUser_role: Sequelize.HasManyHasAssociationMixin<UserRole, UserRoleId>;
	declare hasUser_roles: Sequelize.HasManyHasAssociationsMixin<UserRole, UserRoleId>;
	declare countUser_roles: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany UserRole via created_by
	declare created_by_user_roles: UserRole[];
	declare getCreated_by_user_roles: Sequelize.HasManyGetAssociationsMixin<UserRole>;
	declare setCreated_by_user_roles: Sequelize.HasManySetAssociationsMixin<UserRole, UserRoleId>;
	declare addCreated_by_user_role: Sequelize.HasManyAddAssociationMixin<UserRole, UserRoleId>;
	declare addCreated_by_user_roles: Sequelize.HasManyAddAssociationsMixin<UserRole, UserRoleId>;
	declare createCreated_by_user_role: Sequelize.HasManyCreateAssociationMixin<UserRole>;
	declare removeCreated_by_user_role: Sequelize.HasManyRemoveAssociationMixin<UserRole, UserRoleId>;
	declare removeCreated_by_user_roles: Sequelize.HasManyRemoveAssociationsMixin<UserRole, UserRoleId>;
	declare hasCreated_by_user_role: Sequelize.HasManyHasAssociationMixin<UserRole, UserRoleId>;
	declare hasCreated_by_user_roles: Sequelize.HasManyHasAssociationsMixin<UserRole, UserRoleId>;
	declare countCreated_by_user_roles: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany UserRole via updated_by
	declare updated_by_user_roles: UserRole[];
	declare getUpdated_by_user_roles: Sequelize.HasManyGetAssociationsMixin<UserRole>;
	declare setUpdated_by_user_roles: Sequelize.HasManySetAssociationsMixin<UserRole, UserRoleId>;
	declare addUpdated_by_user_role: Sequelize.HasManyAddAssociationMixin<UserRole, UserRoleId>;
	declare addUpdated_by_user_roles: Sequelize.HasManyAddAssociationsMixin<UserRole, UserRoleId>;
	declare createUpdated_by_user_role: Sequelize.HasManyCreateAssociationMixin<UserRole>;
	declare removeUpdated_by_user_role: Sequelize.HasManyRemoveAssociationMixin<UserRole, UserRoleId>;
	declare removeUpdated_by_user_roles: Sequelize.HasManyRemoveAssociationsMixin<UserRole, UserRoleId>;
	declare hasUpdated_by_user_role: Sequelize.HasManyHasAssociationMixin<UserRole, UserRoleId>;
	declare hasUpdated_by_user_roles: Sequelize.HasManyHasAssociationsMixin<UserRole, UserRoleId>;
	declare countUpdated_by_user_roles: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany UserRole via user_id
	declare user_user_roles: UserRole[];
	declare getUser_user_roles: Sequelize.HasManyGetAssociationsMixin<UserRole>;
	declare setUser_user_roles: Sequelize.HasManySetAssociationsMixin<UserRole, UserRoleId>;
	declare addUser_user_role: Sequelize.HasManyAddAssociationMixin<UserRole, UserRoleId>;
	declare addUser_user_roles: Sequelize.HasManyAddAssociationsMixin<UserRole, UserRoleId>;
	declare createUser_user_role: Sequelize.HasManyCreateAssociationMixin<UserRole>;
	declare removeUser_user_role: Sequelize.HasManyRemoveAssociationMixin<UserRole, UserRoleId>;
	declare removeUser_user_roles: Sequelize.HasManyRemoveAssociationsMixin<UserRole, UserRoleId>;
	declare hasUser_user_role: Sequelize.HasManyHasAssociationMixin<UserRole, UserRoleId>;
	declare hasUser_user_roles: Sequelize.HasManyHasAssociationsMixin<UserRole, UserRoleId>;
	declare countUser_user_roles: Sequelize.HasManyCountAssociationsMixin;
	// User hasMany UserSession via user_id
	declare user_sessions: UserSession[];
	declare getUser_sessions: Sequelize.HasManyGetAssociationsMixin<UserSession>;
	declare setUser_sessions: Sequelize.HasManySetAssociationsMixin<UserSession, UserSessionId>;
	declare addUser_session: Sequelize.HasManyAddAssociationMixin<UserSession, UserSessionId>;
	declare addUser_sessions: Sequelize.HasManyAddAssociationsMixin<UserSession, UserSessionId>;
	declare createUser_session: Sequelize.HasManyCreateAssociationMixin<UserSession>;
	declare removeUser_session: Sequelize.HasManyRemoveAssociationMixin<UserSession, UserSessionId>;
	declare removeUser_sessions: Sequelize.HasManyRemoveAssociationsMixin<UserSession, UserSessionId>;
	declare hasUser_session: Sequelize.HasManyHasAssociationMixin<UserSession, UserSessionId>;
	declare hasUser_sessions: Sequelize.HasManyHasAssociationsMixin<UserSession, UserSessionId>;
	declare countUser_sessions: Sequelize.HasManyCountAssociationsMixin;
	// User belongsTo User via created_by
	declare created_by_user: User;
	declare getCreated_by_user: Sequelize.BelongsToGetAssociationMixin<User>;
	declare setCreated_by_user: Sequelize.BelongsToSetAssociationMixin<User, UserId>;
	declare createCreated_by_user: Sequelize.BelongsToCreateAssociationMixin<User>;
	// User belongsTo User via updated_by
	declare updated_by_user: User;
	declare getUpdated_by_user: Sequelize.BelongsToGetAssociationMixin<User>;
	declare setUpdated_by_user: Sequelize.BelongsToSetAssociationMixin<User, UserId>;
	declare createUpdated_by_user: Sequelize.BelongsToCreateAssociationMixin<User>;
	static initModel(sequelize: Sequelize.Sequelize): typeof User {
		return User.init(
			{
				id: {
					type: DataTypes.UUID,
					allowNull: false,
					defaultValue: DataTypes.UUIDV4,
					primaryKey: true,
				},
				email: {
					type: DataTypes.TEXT,
					allowNull: false,
				},
				username: {
					type: DataTypes.TEXT,
					allowNull: true,
					unique: 'users_username_key',
				},
				first_name: {
					type: DataTypes.STRING(100),
					allowNull: true,
				},
				last_name: {
					type: DataTypes.STRING(100),
					allowNull: true,
				},
				phone: {
					type: DataTypes.STRING(20),
					allowNull: true,
				},
				status: {
					type: DataTypes.ENUM('active', 'inactive', 'suspended', 'pending_verification'),
					allowNull: true,
					defaultValue: 'pending_verification',
				},
				created_by: {
					type: DataTypes.UUID,
					allowNull: true,
					references: {
						model: 'users',
						key: 'id',
					},
				},
				updated_by: {
					type: DataTypes.UUID,
					allowNull: true,
					references: {
						model: 'users',
						key: 'id',
					},
				},
				created_at: {
					type: DataTypes.DATE,
					allowNull: true,
					defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
				},
				updated_at: {
					type: DataTypes.DATE,
					allowNull: true,
					defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
				},
				deleted_at: {
					type: DataTypes.DATE,
					allowNull: true,
				},
				avatar_id: {
					type: DataTypes.UUID,
					allowNull: true,
					references: {
						model: 'files',
						key: 'id',
					},
				},
			},
			{
				sequelize,
				tableName: 'users',
				schema: 'public',
				timestamps: false,

				scopes: {
					default: {
						where: {
							deleted_at: null,
						},
					},
					withDeleted: {},
					onlyDeleted: {
						where: {
							deleted_at: { [Op.ne]: null },
						},
					},
				},
				indexes: [
					{
						name: 'idx_users_avatar_id',
						fields: [{ name: 'avatar_id' }],
					},
					{
						name: 'idx_users_created_at',
						fields: [{ name: 'created_at' }],
					},
					{
						name: 'idx_users_deleted_at',
						fields: [{ name: 'deleted_at' }],
					},
					{
						name: 'idx_users_status',
						fields: [{ name: 'status' }],
					},
					{
						name: 'idx_users_username',
						fields: [{ name: 'username' }],
					},
					{
						name: 'users_pkey',
						unique: true,
						fields: [{ name: 'id' }],
					},
					{
						name: 'users_username_key',
						unique: true,
						fields: [{ name: 'username' }],
					},
					{
						name: 'ux_users_email_active',
						unique: true,
						fields: [{ name: 'email' }],
					},
				],
			},
		);
	}
}
