const db = require('../models');
const Users = db.users;

const AppAccounts = db.app_accounts;

const Applications = db.applications;

const Approvals = db.approvals;

const AuditLogs = db.audit_logs;

const BenefitPlans = db.benefit_plans;

const Bills = db.bills;

const Candidates = db.candidates;

const Cards = db.cards;

const Compensations = db.compensations;

const Deductions = db.deductions;

const Devices = db.devices;

const Documents = db.documents;

const Earnings = db.earnings;

const Employees = db.employees;

const Employments = db.employments;

const EnrollmentLearnings = db.enrollment_learnings;

const Enrollments = db.enrollments;

const ExpenseLines = db.expense_lines;

const ExpenseReports = db.expense_reports;

const Goals = db.goals;

const IdentityAccounts = db.identity_accounts;

const Interviews = db.interviews;

const InventoryEvents = db.inventory_events;

const JobRequisitions = db.job_requisitions;

const LearningCourses = db.learning_courses;

const LeaveRequests = db.leave_requests;

const Offers = db.offers;

const Payments = db.payments;

const PayrollRuns = db.payroll_runs;

const Policies = db.policies;

const Positions = db.positions;

const ReviewCycles = db.review_cycles;

const Reviews = db.reviews;

const ScheduleShifts = db.schedule_shifts;

const Taxes = db.taxes;

const TimeEntries = db.time_entries;

const Timecards = db.timecards;

const TravelBookings = db.travel_bookings;

const Vendors = db.vendors;

const Organizations = db.organizations;

const AppAccountsData = [
  {
    // type code here for "relation_one" field

    role: 'User',

    status: 'Inactive',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    role: 'User',

    status: 'Inactive',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    role: 'SuperAdmin',

    status: 'Active',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    role: 'User',

    status: 'Inactive',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    role: 'User',

    status: 'Inactive',

    // type code here for "relation_one" field
  },
];

const ApplicationsData = [
  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    submitted_at: new Date(Date.now()),

    status: 'Rejected',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    submitted_at: new Date(Date.now()),

    status: 'Reviewed',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    submitted_at: new Date(Date.now()),

    status: 'Rejected',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    submitted_at: new Date(Date.now()),

    status: 'Reviewed',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    submitted_at: new Date(Date.now()),

    status: 'Reviewed',

    // type code here for "relation_one" field
  },
];

const ApprovalsData = [
  {
    object_type: 'Antoine Laurent Lavoisier',

    object_id: 8,

    // type code here for "relation_one" field

    step: 6,

    status: 'Rejected',

    timestamp: new Date(Date.now()),

    // type code here for "relation_one" field
  },

  {
    object_type: 'Marie Curie',

    object_id: 4,

    // type code here for "relation_one" field

    step: 3,

    status: 'Pending',

    timestamp: new Date(Date.now()),

    // type code here for "relation_one" field
  },

  {
    object_type: 'Carl Linnaeus',

    object_id: 5,

    // type code here for "relation_one" field

    step: 2,

    status: 'Approved',

    timestamp: new Date(Date.now()),

    // type code here for "relation_one" field
  },

  {
    object_type: 'James Watson',

    object_id: 9,

    // type code here for "relation_one" field

    step: 7,

    status: 'Rejected',

    timestamp: new Date(Date.now()),

    // type code here for "relation_one" field
  },

  {
    object_type: 'Tycho Brahe',

    object_id: 6,

    // type code here for "relation_one" field

    step: 4,

    status: 'Approved',

    timestamp: new Date(Date.now()),

    // type code here for "relation_one" field
  },
];

const AuditLogsData = [
  {
    actor: 'Sheldon Glashow',

    action: 'Joseph J. Thomson',

    object_type: 'Francis Crick',

    object_id: 1,

    timestamp: new Date(Date.now()),

    diff: 'Lynn Margulis',

    // type code here for "relation_one" field
  },

  {
    actor: 'Euclid',

    action: 'William Harvey',

    object_type: 'Robert Koch',

    object_id: 5,

    timestamp: new Date(Date.now()),

    diff: 'Thomas Hunt Morgan',

    // type code here for "relation_one" field
  },

  {
    actor: 'Thomas Hunt Morgan',

    action: 'Marcello Malpighi',

    object_type: 'Alfred Wegener',

    object_id: 7,

    timestamp: new Date(Date.now()),

    diff: 'Hans Bethe',

    // type code here for "relation_one" field
  },

  {
    actor: 'J. Robert Oppenheimer',

    action: 'Alexander Fleming',

    object_type: 'Lynn Margulis',

    object_id: 1,

    timestamp: new Date(Date.now()),

    diff: 'Gregor Mendel',

    // type code here for "relation_one" field
  },

  {
    actor: 'Charles Darwin',

    action: 'Anton van Leeuwenhoek',

    object_type: 'Thomas Hunt Morgan',

    object_id: 6,

    timestamp: new Date(Date.now()),

    diff: 'Carl Linnaeus',

    // type code here for "relation_one" field
  },
];

const BenefitPlansData = [
  {
    carrier: 'Johannes Kepler',

    plan_type: 'Dental',

    country: 'Gustav Kirchhoff',

    currency: 'Nicolaus Copernicus',

    // type code here for "relation_one" field
  },

  {
    carrier: 'Justus Liebig',

    plan_type: 'Dental',

    country: 'Paul Ehrlich',

    currency: 'Charles Lyell',

    // type code here for "relation_one" field
  },

  {
    carrier: 'Sigmund Freud',

    plan_type: 'Medical',

    country: 'Euclid',

    currency: 'J. Robert Oppenheimer',

    // type code here for "relation_one" field
  },

  {
    carrier: 'Sigmund Freud',

    plan_type: 'Dental',

    country: 'James Clerk Maxwell',

    currency: 'Erwin Schrodinger',

    // type code here for "relation_one" field
  },

  {
    carrier: 'Trofim Lysenko',

    plan_type: 'Dental',

    country: 'Edward O. Wilson',

    currency: 'Konrad Lorenz',

    // type code here for "relation_one" field
  },
];

const BillsData = [
  {
    // type code here for "relation_one" field

    invoice_no: 'Hans Selye',

    invoice_date: new Date(Date.now()),

    due_date: new Date(Date.now()),

    amount: 42.88,

    currency: 'Edward Teller',

    category: 'Emil Fischer',

    status: 'Paid',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    invoice_no: 'Charles Sherrington',

    invoice_date: new Date(Date.now()),

    due_date: new Date(Date.now()),

    amount: 43.66,

    currency: 'Max Born',

    category: 'Frederick Gowland Hopkins',

    status: 'Overdue',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    invoice_no: 'James Watson',

    invoice_date: new Date(Date.now()),

    due_date: new Date(Date.now()),

    amount: 21.71,

    currency: 'Albrecht von Haller',

    category: 'Lynn Margulis',

    status: 'Overdue',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    invoice_no: 'Claude Bernard',

    invoice_date: new Date(Date.now()),

    due_date: new Date(Date.now()),

    amount: 93.32,

    currency: 'Albert Einstein',

    category: 'Charles Darwin',

    status: 'Overdue',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    invoice_no: 'John von Neumann',

    invoice_date: new Date(Date.now()),

    due_date: new Date(Date.now()),

    amount: 55.46,

    currency: 'Sheldon Glashow',

    category: 'Edward O. Wilson',

    status: 'Paid',

    // type code here for "relation_one" field
  },
];

const CandidatesData = [
  {
    name: 'Thomas Hunt Morgan',

    email: 'Claude Levi-Strauss',

    phone: 'Euclid',

    source: 'Alfred Binet',

    current_stage: 'Interviewing',

    // type code here for "relation_one" field
  },

  {
    name: 'John Dalton',

    email: 'Max Born',

    phone: 'William Bayliss',

    source: 'Carl Linnaeus',

    current_stage: 'Interviewing',

    // type code here for "relation_one" field
  },

  {
    name: 'Alfred Binet',

    email: 'J. Robert Oppenheimer',

    phone: 'Emil Kraepelin',

    source: 'Michael Faraday',

    current_stage: 'Interviewing',

    // type code here for "relation_one" field
  },

  {
    name: 'Dmitri Mendeleev',

    email: 'Hans Selye',

    phone: 'Carl Linnaeus',

    source: 'Frederick Sanger',

    current_stage: 'Offered',

    // type code here for "relation_one" field
  },

  {
    name: 'Emil Fischer',

    email: 'Michael Faraday',

    phone: 'Marie Curie',

    source: 'John von Neumann',

    current_stage: 'Applied',

    // type code here for "relation_one" field
  },
];

const CardsData = [
  {
    // type code here for "relation_one" field

    type: 'Physical',

    last4: 'J. Robert Oppenheimer',

    limit: 48.09,

    status: 'Inactive',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'Physical',

    last4: 'Werner Heisenberg',

    limit: 39.62,

    status: 'Active',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'Virtual',

    last4: 'Ernest Rutherford',

    limit: 74.48,

    status: 'Active',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'Physical',

    last4: 'Charles Sherrington',

    limit: 46.48,

    status: 'Inactive',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'Virtual',

    last4: 'Isaac Newton',

    limit: 17.02,

    status: 'Inactive',

    // type code here for "relation_one" field
  },
];

const CompensationsData = [
  {
    // type code here for "relation_one" field

    base_pay: 60000,

    pay_type: 'Salary',

    pay_frequency: 'Bi-weekly',

    currency: 'USD',

    effective_date: new Date('2023-01-01T00:00:00Z'),

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    base_pay: 30000,

    pay_type: 'Hourly',

    pay_frequency: 'Monthly',

    currency: 'USD',

    effective_date: new Date('2023-02-01T00:00:00Z'),

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    base_pay: 45000,

    pay_type: 'Hourly',

    pay_frequency: 'Bi-weekly',

    currency: 'USD',

    effective_date: new Date('2023-03-01T00:00:00Z'),

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    base_pay: 55000,

    pay_type: 'Salary',

    pay_frequency: 'Bi-weekly',

    currency: 'USD',

    effective_date: new Date('2023-04-01T00:00:00Z'),

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    base_pay: 25000,

    pay_type: 'Salary',

    pay_frequency: 'Bi-weekly',

    currency: 'USD',

    effective_date: new Date('2023-05-01T00:00:00Z'),

    // type code here for "relation_one" field
  },
];

const DeductionsData = [
  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    type: 'Tax',

    amount: 92.44,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    type: 'Tax',

    amount: 45.47,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    type: 'Other',

    amount: 99.77,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    type: 'Tax',

    amount: 21.76,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    type: 'Other',

    amount: 47.34,

    // type code here for "relation_one" field
  },
];

const DevicesData = [
  {
    type: 'Laptop',

    platform: 'Linux',

    serial: 'Paul Ehrlich',

    asset_tag: 'Edward O. Wilson',

    // type code here for "relation_one" field

    status: 'Assigned',

    encryption: true,

    os_version: 'Ernest Rutherford',

    // type code here for "relation_one" field
  },

  {
    type: 'Laptop',

    platform: 'MacOS',

    serial: 'Edwin Hubble',

    asset_tag: 'Thomas Hunt Morgan',

    // type code here for "relation_one" field

    status: 'Assigned',

    encryption: true,

    os_version: 'Werner Heisenberg',

    // type code here for "relation_one" field
  },

  {
    type: 'Tablet',

    platform: 'Linux',

    serial: 'Karl Landsteiner',

    asset_tag: 'William Herschel',

    // type code here for "relation_one" field

    status: 'Assigned',

    encryption: true,

    os_version: 'Anton van Leeuwenhoek',

    // type code here for "relation_one" field
  },

  {
    type: 'Laptop',

    platform: 'MacOS',

    serial: 'Alfred Binet',

    asset_tag: 'Hans Bethe',

    // type code here for "relation_one" field

    status: 'Retired',

    encryption: true,

    os_version: 'Lucretius',

    // type code here for "relation_one" field
  },

  {
    type: 'Tablet',

    platform: 'MacOS',

    serial: 'William Harvey',

    asset_tag: 'Carl Linnaeus',

    // type code here for "relation_one" field

    status: 'Retired',

    encryption: false,

    os_version: 'John Dalton',

    // type code here for "relation_one" field
  },
];

const DocumentsData = [
  {
    // type code here for "relation_one" field

    doc_type: 'ID',

    country: 'USA',

    status: 'Signed',

    signed_at: new Date('2023-01-01T00:00:00Z'),

    // type code here for "files" field

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    doc_type: 'Certificate',

    country: 'USA',

    status: 'Pending',

    signed_at: new Date('2023-02-01T00:00:00Z'),

    // type code here for "files" field

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    doc_type: 'ID',

    country: 'USA',

    status: 'Expired',

    signed_at: new Date('2023-03-01T00:00:00Z'),

    // type code here for "files" field

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    doc_type: 'Certificate',

    country: 'USA',

    status: 'Pending',

    signed_at: new Date('2023-04-01T00:00:00Z'),

    // type code here for "files" field

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    doc_type: 'Contract',

    country: 'USA',

    status: 'Signed',

    signed_at: new Date('2023-05-01T00:00:00Z'),

    // type code here for "files" field

    // type code here for "relation_one" field
  },
];

const EarningsData = [
  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    component: 'Karl Landsteiner',

    units: 64.05,

    rate: 95.13,

    amount: 82.23,

    currency: 'Charles Lyell',

    taxable: false,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    component: 'Tycho Brahe',

    units: 95.73,

    rate: 52.15,

    amount: 32.13,

    currency: 'Archimedes',

    taxable: false,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    component: 'Christiaan Huygens',

    units: 41.46,

    rate: 69.73,

    amount: 94.02,

    currency: 'Lynn Margulis',

    taxable: true,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    component: 'Karl Landsteiner',

    units: 61.11,

    rate: 48.59,

    amount: 83.31,

    currency: 'Enrico Fermi',

    taxable: false,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    component: 'Willard Libby',

    units: 27.56,

    rate: 98.22,

    amount: 47.13,

    currency: 'John von Neumann',

    taxable: true,

    // type code here for "relation_one" field
  },
];

const EmployeesData = [
  {
    // type code here for "relation_one" field
    // type code here for "relation_many" field
    // type code here for "relation_many" field
    // type code here for "relation_many" field
    // type code here for "relation_many" field
    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field
    // type code here for "relation_many" field
    // type code here for "relation_many" field
    // type code here for "relation_many" field
    // type code here for "relation_many" field
    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field
    // type code here for "relation_many" field
    // type code here for "relation_many" field
    // type code here for "relation_many" field
    // type code here for "relation_many" field
    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field
    // type code here for "relation_many" field
    // type code here for "relation_many" field
    // type code here for "relation_many" field
    // type code here for "relation_many" field
    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field
    // type code here for "relation_many" field
    // type code here for "relation_many" field
    // type code here for "relation_many" field
    // type code here for "relation_many" field
    // type code here for "relation_one" field
  },
];

const EmploymentsData = [
  {
    // type code here for "relation_one" field

    employment_type: 'Full-time',

    start_date: new Date('2023-01-01T00:00:00Z'),

    end_date: new Date('2023-12-31T00:00:00Z'),

    fte: 1,

    status: 'Active',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    employment_type: 'Contractor',

    start_date: new Date('2023-02-01T00:00:00Z'),

    end_date: new Date('2023-11-30T00:00:00Z'),

    fte: 0.5,

    status: 'Active',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    employment_type: 'Part-time',

    start_date: new Date('2023-03-01T00:00:00Z'),

    end_date: new Date('2023-09-30T00:00:00Z'),

    fte: 0.75,

    status: 'Active',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    employment_type: 'Contractor',

    start_date: new Date('2023-04-01T00:00:00Z'),

    end_date: new Date('2023-10-31T00:00:00Z'),

    fte: 1,

    status: 'Terminated',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    employment_type: 'Part-time',

    start_date: new Date('2023-05-01T00:00:00Z'),

    end_date: new Date('2023-08-31T00:00:00Z'),

    fte: 0.5,

    status: 'Terminated',

    // type code here for "relation_one" field
  },
];

const EnrollmentLearningsData = [
  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    due_date: new Date(Date.now()),

    status: 'Overdue',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    due_date: new Date(Date.now()),

    status: 'Completed',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    due_date: new Date(Date.now()),

    status: 'Assigned',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    due_date: new Date(Date.now()),

    status: 'Assigned',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    due_date: new Date(Date.now()),

    status: 'Overdue',

    // type code here for "relation_one" field
  },
];

const EnrollmentsData = [
  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    effective_date: new Date(Date.now()),

    premium_employee: 33.88,

    premium_employer: 94.07,

    status: 'Active',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    effective_date: new Date(Date.now()),

    premium_employee: 57.84,

    premium_employer: 50.41,

    status: 'Active',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    effective_date: new Date(Date.now()),

    premium_employee: 21.38,

    premium_employer: 49.11,

    status: 'Active',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    effective_date: new Date(Date.now()),

    premium_employee: 95.57,

    premium_employer: 27.18,

    status: 'Inactive',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    effective_date: new Date(Date.now()),

    premium_employee: 43.94,

    premium_employer: 90.45,

    status: 'Inactive',

    // type code here for "relation_one" field
  },
];

const ExpenseLinesData = [
  {
    // type code here for "relation_one" field

    date: new Date(Date.now()),

    merchant: 'Max Born',

    amount: 21.84,

    currency: 'Sigmund Freud',

    category: 'Murray Gell-Mann',

    // type code here for "files" field

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    date: new Date(Date.now()),

    merchant: 'Stephen Hawking',

    amount: 79.11,

    currency: 'Konrad Lorenz',

    category: 'Thomas Hunt Morgan',

    // type code here for "files" field

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    date: new Date(Date.now()),

    merchant: 'Murray Gell-Mann',

    amount: 19.78,

    currency: 'Tycho Brahe',

    category: 'Charles Lyell',

    // type code here for "files" field

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    date: new Date(Date.now()),

    merchant: 'Christiaan Huygens',

    amount: 19.92,

    currency: 'Heike Kamerlingh Onnes',

    category: 'Charles Sherrington',

    // type code here for "files" field

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    date: new Date(Date.now()),

    merchant: 'Heike Kamerlingh Onnes',

    amount: 13.72,

    currency: 'Louis Victor de Broglie',

    category: 'Noam Chomsky',

    // type code here for "files" field

    // type code here for "relation_one" field
  },
];

const ExpenseReportsData = [
  {
    // type code here for "relation_one" field

    submitted_at: new Date(Date.now()),

    status: 'Approved',

    policy_result: 'William Herschel',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    submitted_at: new Date(Date.now()),

    status: 'Pending',

    policy_result: 'William Bayliss',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    submitted_at: new Date(Date.now()),

    status: 'Pending',

    policy_result: 'John Bardeen',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    submitted_at: new Date(Date.now()),

    status: 'Approved',

    policy_result: 'Frederick Sanger',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    submitted_at: new Date(Date.now()),

    status: 'Pending',

    policy_result: 'Gregor Mendel',

    // type code here for "relation_one" field
  },
];

const GoalsData = [
  {
    // type code here for "relation_one" field

    type: 'Personal',

    title: 'Louis Pasteur',

    metric: 'Lynn Margulis',

    target: 71.14,

    start: new Date(Date.now()),

    due: new Date(Date.now()),

    progress: 43.45,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'Personal',

    title: 'Noam Chomsky',

    metric: 'Hermann von Helmholtz',

    target: 85.05,

    start: new Date(Date.now()),

    due: new Date(Date.now()),

    progress: 73.73,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'Personal',

    title: 'Paul Dirac',

    metric: 'Erwin Schrodinger',

    target: 32.79,

    start: new Date(Date.now()),

    due: new Date(Date.now()),

    progress: 46.23,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'Personal',

    title: 'Thomas Hunt Morgan',

    metric: 'Theodosius Dobzhansky',

    target: 61.71,

    start: new Date(Date.now()),

    due: new Date(Date.now()),

    progress: 59.19,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'Company',

    title: 'Noam Chomsky',

    metric: 'Neils Bohr',

    target: 60.66,

    start: new Date(Date.now()),

    due: new Date(Date.now()),

    progress: 86.34,

    // type code here for "relation_one" field
  },
];

const IdentityAccountsData = [
  {
    // type code here for "relation_one" field

    idp: 'Trofim Lysenko',

    username: 'Enrico Fermi',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    idp: 'Isaac Newton',

    username: 'Anton van Leeuwenhoek',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    idp: 'Euclid',

    username: 'Hermann von Helmholtz',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    idp: 'Paul Dirac',

    username: 'Lucretius',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    idp: 'Ernst Mayr',

    username: 'Ernst Mayr',

    // type code here for "relation_one" field
  },
];

const InterviewsData = [
  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    type: 'Phone',

    scheduled_at: new Date(Date.now()),

    rating: 98.85,

    notes: 'Alexander Fleming',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    type: 'Onsite',

    scheduled_at: new Date(Date.now()),

    rating: 69.98,

    notes: 'Sigmund Freud',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    type: 'Onsite',

    scheduled_at: new Date(Date.now()),

    rating: 20.07,

    notes: 'Sheldon Glashow',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    type: 'Onsite',

    scheduled_at: new Date(Date.now()),

    rating: 45.97,

    notes: 'Louis Victor de Broglie',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    type: 'Onsite',

    scheduled_at: new Date(Date.now()),

    rating: 18.94,

    notes: 'Linus Pauling',

    // type code here for "relation_one" field
  },
];

const InventoryEventsData = [
  {
    // type code here for "relation_one" field

    event_type: 'Returned',

    timestamp: new Date(Date.now()),

    metadata: 'Gertrude Belle Elion',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    event_type: 'Returned',

    timestamp: new Date(Date.now()),

    metadata: 'Trofim Lysenko',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    event_type: 'Repaired',

    timestamp: new Date(Date.now()),

    metadata: 'Franz Boas',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    event_type: 'Repaired',

    timestamp: new Date(Date.now()),

    metadata: 'Stephen Hawking',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    event_type: 'Returned',

    timestamp: new Date(Date.now()),

    metadata: 'Charles Sherrington',

    // type code here for "relation_one" field
  },
];

const JobRequisitionsData = [
  {
    title: 'Alfred Wegener',

    employment_type: 'Part-time',

    openings: 7,

    status: 'OnHold',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    title: 'Max Born',

    employment_type: 'Full-time',

    openings: 6,

    status: 'Open',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    title: 'Lynn Margulis',

    employment_type: 'Full-time',

    openings: 6,

    status: 'Open',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    title: 'Murray Gell-Mann',

    employment_type: 'Part-time',

    openings: 1,

    status: 'OnHold',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    title: 'Alfred Binet',

    employment_type: 'Part-time',

    openings: 4,

    status: 'OnHold',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const LearningCoursesData = [
  {
    title: 'J. Robert Oppenheimer',

    provider: 'Heike Kamerlingh Onnes',

    hours: 59.86,

    compliance_tag: 'Konrad Lorenz',

    // type code here for "relation_one" field
  },

  {
    title: 'Carl Linnaeus',

    provider: 'Rudolf Virchow',

    hours: 62.54,

    compliance_tag: 'Lucretius',

    // type code here for "relation_one" field
  },

  {
    title: 'Comte de Buffon',

    provider: 'James Clerk Maxwell',

    hours: 94.83,

    compliance_tag: 'John Dalton',

    // type code here for "relation_one" field
  },

  {
    title: 'Charles Darwin',

    provider: 'William Bayliss',

    hours: 35.61,

    compliance_tag: 'Trofim Lysenko',

    // type code here for "relation_one" field
  },

  {
    title: 'Charles Lyell',

    provider: 'Karl Landsteiner',

    hours: 70.68,

    compliance_tag: 'Max von Laue',

    // type code here for "relation_one" field
  },
];

const LeaveRequestsData = [
  {
    // type code here for "relation_one" field

    type: 'Sick',

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    hours: 34.67,

    status: 'Approved',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'Vacation',

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    hours: 28.72,

    status: 'Approved',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'Unpaid',

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    hours: 95.38,

    status: 'Rejected',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'Vacation',

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    hours: 29.07,

    status: 'Approved',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'Unpaid',

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    hours: 94.47,

    status: 'Approved',

    // type code here for "relation_one" field
  },
];

const OffersData = [
  {
    // type code here for "relation_one" field

    comp_package: 'Ludwig Boltzmann',

    target_start_date: new Date(Date.now()),

    status: 'Sent',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    comp_package: 'Francis Galton',

    target_start_date: new Date(Date.now()),

    status: 'Sent',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    comp_package: 'Charles Lyell',

    target_start_date: new Date(Date.now()),

    status: 'Sent',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    comp_package: 'William Herschel',

    target_start_date: new Date(Date.now()),

    status: 'Declined',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    comp_package: 'Isaac Newton',

    target_start_date: new Date(Date.now()),

    status: 'Sent',

    // type code here for "relation_one" field
  },
];

const PaymentsData = [
  {
    // type code here for "relation_one" field

    method: 'CreditCard',

    paid_at: new Date(Date.now()),

    amount: 31.75,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    method: 'CreditCard',

    paid_at: new Date(Date.now()),

    amount: 90.14,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    method: 'BankTransfer',

    paid_at: new Date(Date.now()),

    amount: 61.05,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    method: 'CreditCard',

    paid_at: new Date(Date.now()),

    amount: 15.37,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    method: 'Cash',

    paid_at: new Date(Date.now()),

    amount: 98.95,

    // type code here for "relation_one" field
  },
];

const PayrollRunsData = [
  {
    country: 'Leonard Euler',

    pay_period_start: new Date(Date.now()),

    pay_period_end: new Date(Date.now()),

    pay_date: new Date(Date.now()),

    status: 'Processed',

    // type code here for "relation_one" field
  },

  {
    country: 'Hans Bethe',

    pay_period_start: new Date(Date.now()),

    pay_period_end: new Date(Date.now()),

    pay_date: new Date(Date.now()),

    status: 'Processed',

    // type code here for "relation_one" field
  },

  {
    country: 'Alexander Fleming',

    pay_period_start: new Date(Date.now()),

    pay_period_end: new Date(Date.now()),

    pay_date: new Date(Date.now()),

    status: 'Processed',

    // type code here for "relation_one" field
  },

  {
    country: 'Werner Heisenberg',

    pay_period_start: new Date(Date.now()),

    pay_period_end: new Date(Date.now()),

    pay_date: new Date(Date.now()),

    status: 'Open',

    // type code here for "relation_one" field
  },

  {
    country: 'Edward O. Wilson',

    pay_period_start: new Date(Date.now()),

    pay_period_end: new Date(Date.now()),

    pay_date: new Date(Date.now()),

    status: 'Open',

    // type code here for "relation_one" field
  },
];

const PoliciesData = [
  {
    scope: 'Max Planck',

    rule_logic: 'Emil Kraepelin',

    effect: 'Deny',

    // type code here for "relation_one" field
  },

  {
    scope: 'Charles Darwin',

    rule_logic: 'Emil Kraepelin',

    effect: 'Deny',

    // type code here for "relation_one" field
  },

  {
    scope: 'Robert Koch',

    rule_logic: 'Pierre Simon de Laplace',

    effect: 'Allow',

    // type code here for "relation_one" field
  },

  {
    scope: 'Justus Liebig',

    rule_logic: 'Trofim Lysenko',

    effect: 'Allow',

    // type code here for "relation_one" field
  },

  {
    scope: 'Noam Chomsky',

    rule_logic: 'Konrad Lorenz',

    effect: 'Allow',

    // type code here for "relation_one" field
  },
];

const PositionsData = [
  {
    title: 'Software Engineer',

    job_family: 'Engineering',

    level: 'Junior',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    title: 'Product Manager',

    job_family: 'Product',

    level: 'Mid',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    title: 'HR Specialist',

    job_family: 'Human Resources',

    level: 'Senior',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    title: 'Sales Executive',

    job_family: 'Sales',

    level: 'Mid',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    title: 'Marketing Coordinator',

    job_family: 'Marketing',

    level: 'Junior',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const ReviewCyclesData = [
  {
    name: 'Frederick Gowland Hopkins',

    cycle_start: new Date(Date.now()),

    cycle_end: new Date(Date.now()),

    status: 'Open',

    // type code here for "relation_one" field
  },

  {
    name: 'Gustav Kirchhoff',

    cycle_start: new Date(Date.now()),

    cycle_end: new Date(Date.now()),

    status: 'Closed',

    // type code here for "relation_one" field
  },

  {
    name: 'Ernest Rutherford',

    cycle_start: new Date(Date.now()),

    cycle_end: new Date(Date.now()),

    status: 'Open',

    // type code here for "relation_one" field
  },

  {
    name: 'Claude Bernard',

    cycle_start: new Date(Date.now()),

    cycle_end: new Date(Date.now()),

    status: 'Closed',

    // type code here for "relation_one" field
  },

  {
    name: 'Isaac Newton',

    cycle_start: new Date(Date.now()),

    cycle_end: new Date(Date.now()),

    status: 'Closed',

    // type code here for "relation_one" field
  },
];

const ReviewsData = [
  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    comments: 'Johannes Kepler',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    comments: 'Robert Koch',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    comments: 'Archimedes',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    comments: 'Dmitri Mendeleev',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    comments: 'August Kekule',

    // type code here for "relation_one" field
  },
];

const ScheduleShiftsData = [
  {
    // type code here for "relation_one" field

    date: new Date(Date.now()),

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    role: 'Max Delbruck',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    date: new Date(Date.now()),

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    role: 'Carl Linnaeus',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    date: new Date(Date.now()),

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    role: 'Ernst Mayr',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    date: new Date(Date.now()),

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    role: 'Claude Levi-Strauss',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    date: new Date(Date.now()),

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    role: 'Edward O. Wilson',

    // type code here for "relation_one" field
  },
];

const TaxesData = [
  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    jurisdiction: 'Frederick Sanger',

    amount: 74.55,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    jurisdiction: 'Louis Pasteur',

    amount: 69.59,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    jurisdiction: 'Wilhelm Wundt',

    amount: 48.22,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    jurisdiction: 'George Gaylord Simpson',

    amount: 87.34,

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    // type code here for "relation_one" field

    jurisdiction: 'Charles Lyell',

    amount: 17.53,

    // type code here for "relation_one" field
  },
];

const TimeEntriesData = [
  {
    // type code here for "relation_one" field

    date: new Date(Date.now()),

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    break_minutes: 2,

    job_code: 'Jean Piaget',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    date: new Date(Date.now()),

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    break_minutes: 5,

    job_code: 'Michael Faraday',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    date: new Date(Date.now()),

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    break_minutes: 1,

    job_code: 'Franz Boas',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    date: new Date(Date.now()),

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    break_minutes: 7,

    job_code: 'Neils Bohr',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    date: new Date(Date.now()),

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    break_minutes: 3,

    job_code: 'Edwin Hubble',

    // type code here for "relation_one" field
  },
];

const TimecardsData = [
  {
    // type code here for "relation_one" field

    period: 'Enrico Fermi',

    status: 'Rejected',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    period: 'Noam Chomsky',

    status: 'Approved',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    period: 'Tycho Brahe',

    status: 'Rejected',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    period: 'August Kekule',

    status: 'Rejected',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    period: 'Arthur Eddington',

    status: 'Approved',

    // type code here for "relation_one" field
  },
];

const TravelBookingsData = [
  {
    // type code here for "relation_one" field

    type: 'Flight',

    provider: 'Marie Curie',

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    cost: 99.73,

    policy_result: 'William Harvey',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'Flight',

    provider: 'Werner Heisenberg',

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    cost: 98.56,

    policy_result: 'William Bayliss',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'CarRental',

    provider: 'Theodosius Dobzhansky',

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    cost: 69.31,

    policy_result: 'Heike Kamerlingh Onnes',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'Flight',

    provider: 'Lynn Margulis',

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    cost: 54.24,

    policy_result: 'Willard Libby',

    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field

    type: 'CarRental',

    provider: 'Erwin Schrodinger',

    start: new Date(Date.now()),

    end: new Date(Date.now()),

    cost: 39.46,

    policy_result: 'Lucretius',

    // type code here for "relation_one" field
  },
];

const VendorsData = [
  {
    name: 'Konrad Lorenz',

    tax_id: 'B. F. Skinner',

    country: 'Max von Laue',

    currency: 'Francis Crick',

    // type code here for "relation_one" field
  },

  {
    name: 'Francis Galton',

    tax_id: 'Neils Bohr',

    country: 'Paul Dirac',

    currency: 'Ernst Haeckel',

    // type code here for "relation_one" field
  },

  {
    name: 'James Watson',

    tax_id: 'Charles Darwin',

    country: 'Stephen Hawking',

    currency: 'Comte de Buffon',

    // type code here for "relation_one" field
  },

  {
    name: 'Max von Laue',

    tax_id: 'Hans Selye',

    country: 'Gregor Mendel',

    currency: 'Gregor Mendel',

    // type code here for "relation_one" field
  },

  {
    name: 'Ernest Rutherford',

    tax_id: 'Robert Koch',

    country: 'Claude Bernard',

    currency: 'Isaac Newton',

    // type code here for "relation_one" field
  },
];

const OrganizationsData = [
  {
    name: 'George Gaylord Simpson',
  },

  {
    name: 'Andreas Vesalius',
  },

  {
    name: 'John Dalton',
  },

  {
    name: 'Charles Lyell',
  },

  {
    name: 'Albrecht von Haller',
  },
];

// Similar logic for "relation_many"

async function associateUserWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const User0 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (User0?.setOrganization) {
    await User0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const User1 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (User1?.setOrganization) {
    await User1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const User2 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (User2?.setOrganization) {
    await User2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const User3 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (User3?.setOrganization) {
    await User3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const User4 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (User4?.setOrganization) {
    await User4.setOrganization(relatedOrganization4);
  }
}

async function associateAppAccountWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const AppAccount0 = await AppAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (AppAccount0?.setEmployee) {
    await AppAccount0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const AppAccount1 = await AppAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (AppAccount1?.setEmployee) {
    await AppAccount1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const AppAccount2 = await AppAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (AppAccount2?.setEmployee) {
    await AppAccount2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const AppAccount3 = await AppAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (AppAccount3?.setEmployee) {
    await AppAccount3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const AppAccount4 = await AppAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (AppAccount4?.setEmployee) {
    await AppAccount4.setEmployee(relatedEmployee4);
  }
}

async function associateAppAccountWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const AppAccount0 = await AppAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (AppAccount0?.setOrganization) {
    await AppAccount0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const AppAccount1 = await AppAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (AppAccount1?.setOrganization) {
    await AppAccount1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const AppAccount2 = await AppAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (AppAccount2?.setOrganization) {
    await AppAccount2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const AppAccount3 = await AppAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (AppAccount3?.setOrganization) {
    await AppAccount3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const AppAccount4 = await AppAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (AppAccount4?.setOrganization) {
    await AppAccount4.setOrganization(relatedOrganization4);
  }
}

async function associateApplicationWithCandidate() {
  const relatedCandidate0 = await Candidates.findOne({
    offset: Math.floor(Math.random() * (await Candidates.count())),
  });
  const Application0 = await Applications.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Application0?.setCandidate) {
    await Application0.setCandidate(relatedCandidate0);
  }

  const relatedCandidate1 = await Candidates.findOne({
    offset: Math.floor(Math.random() * (await Candidates.count())),
  });
  const Application1 = await Applications.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Application1?.setCandidate) {
    await Application1.setCandidate(relatedCandidate1);
  }

  const relatedCandidate2 = await Candidates.findOne({
    offset: Math.floor(Math.random() * (await Candidates.count())),
  });
  const Application2 = await Applications.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Application2?.setCandidate) {
    await Application2.setCandidate(relatedCandidate2);
  }

  const relatedCandidate3 = await Candidates.findOne({
    offset: Math.floor(Math.random() * (await Candidates.count())),
  });
  const Application3 = await Applications.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Application3?.setCandidate) {
    await Application3.setCandidate(relatedCandidate3);
  }

  const relatedCandidate4 = await Candidates.findOne({
    offset: Math.floor(Math.random() * (await Candidates.count())),
  });
  const Application4 = await Applications.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Application4?.setCandidate) {
    await Application4.setCandidate(relatedCandidate4);
  }
}

async function associateApplicationWithRequisition() {
  const relatedRequisition0 = await JobRequisitions.findOne({
    offset: Math.floor(Math.random() * (await JobRequisitions.count())),
  });
  const Application0 = await Applications.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Application0?.setRequisition) {
    await Application0.setRequisition(relatedRequisition0);
  }

  const relatedRequisition1 = await JobRequisitions.findOne({
    offset: Math.floor(Math.random() * (await JobRequisitions.count())),
  });
  const Application1 = await Applications.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Application1?.setRequisition) {
    await Application1.setRequisition(relatedRequisition1);
  }

  const relatedRequisition2 = await JobRequisitions.findOne({
    offset: Math.floor(Math.random() * (await JobRequisitions.count())),
  });
  const Application2 = await Applications.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Application2?.setRequisition) {
    await Application2.setRequisition(relatedRequisition2);
  }

  const relatedRequisition3 = await JobRequisitions.findOne({
    offset: Math.floor(Math.random() * (await JobRequisitions.count())),
  });
  const Application3 = await Applications.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Application3?.setRequisition) {
    await Application3.setRequisition(relatedRequisition3);
  }

  const relatedRequisition4 = await JobRequisitions.findOne({
    offset: Math.floor(Math.random() * (await JobRequisitions.count())),
  });
  const Application4 = await Applications.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Application4?.setRequisition) {
    await Application4.setRequisition(relatedRequisition4);
  }
}

async function associateApplicationWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Application0 = await Applications.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Application0?.setOrganization) {
    await Application0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Application1 = await Applications.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Application1?.setOrganization) {
    await Application1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Application2 = await Applications.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Application2?.setOrganization) {
    await Application2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Application3 = await Applications.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Application3?.setOrganization) {
    await Application3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Application4 = await Applications.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Application4?.setOrganization) {
    await Application4.setOrganization(relatedOrganization4);
  }
}

async function associateApprovalWithApprover() {
  const relatedApprover0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Approval0 = await Approvals.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Approval0?.setApprover) {
    await Approval0.setApprover(relatedApprover0);
  }

  const relatedApprover1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Approval1 = await Approvals.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Approval1?.setApprover) {
    await Approval1.setApprover(relatedApprover1);
  }

  const relatedApprover2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Approval2 = await Approvals.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Approval2?.setApprover) {
    await Approval2.setApprover(relatedApprover2);
  }

  const relatedApprover3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Approval3 = await Approvals.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Approval3?.setApprover) {
    await Approval3.setApprover(relatedApprover3);
  }

  const relatedApprover4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Approval4 = await Approvals.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Approval4?.setApprover) {
    await Approval4.setApprover(relatedApprover4);
  }
}

async function associateApprovalWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Approval0 = await Approvals.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Approval0?.setOrganization) {
    await Approval0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Approval1 = await Approvals.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Approval1?.setOrganization) {
    await Approval1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Approval2 = await Approvals.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Approval2?.setOrganization) {
    await Approval2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Approval3 = await Approvals.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Approval3?.setOrganization) {
    await Approval3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Approval4 = await Approvals.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Approval4?.setOrganization) {
    await Approval4.setOrganization(relatedOrganization4);
  }
}

async function associateAuditLogWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const AuditLog0 = await AuditLogs.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (AuditLog0?.setOrganization) {
    await AuditLog0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const AuditLog1 = await AuditLogs.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (AuditLog1?.setOrganization) {
    await AuditLog1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const AuditLog2 = await AuditLogs.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (AuditLog2?.setOrganization) {
    await AuditLog2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const AuditLog3 = await AuditLogs.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (AuditLog3?.setOrganization) {
    await AuditLog3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const AuditLog4 = await AuditLogs.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (AuditLog4?.setOrganization) {
    await AuditLog4.setOrganization(relatedOrganization4);
  }
}

async function associateBenefitPlanWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const BenefitPlan0 = await BenefitPlans.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (BenefitPlan0?.setOrganization) {
    await BenefitPlan0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const BenefitPlan1 = await BenefitPlans.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (BenefitPlan1?.setOrganization) {
    await BenefitPlan1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const BenefitPlan2 = await BenefitPlans.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (BenefitPlan2?.setOrganization) {
    await BenefitPlan2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const BenefitPlan3 = await BenefitPlans.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (BenefitPlan3?.setOrganization) {
    await BenefitPlan3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const BenefitPlan4 = await BenefitPlans.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (BenefitPlan4?.setOrganization) {
    await BenefitPlan4.setOrganization(relatedOrganization4);
  }
}

async function associateBillWithVendor() {
  const relatedVendor0 = await Vendors.findOne({
    offset: Math.floor(Math.random() * (await Vendors.count())),
  });
  const Bill0 = await Bills.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Bill0?.setVendor) {
    await Bill0.setVendor(relatedVendor0);
  }

  const relatedVendor1 = await Vendors.findOne({
    offset: Math.floor(Math.random() * (await Vendors.count())),
  });
  const Bill1 = await Bills.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Bill1?.setVendor) {
    await Bill1.setVendor(relatedVendor1);
  }

  const relatedVendor2 = await Vendors.findOne({
    offset: Math.floor(Math.random() * (await Vendors.count())),
  });
  const Bill2 = await Bills.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Bill2?.setVendor) {
    await Bill2.setVendor(relatedVendor2);
  }

  const relatedVendor3 = await Vendors.findOne({
    offset: Math.floor(Math.random() * (await Vendors.count())),
  });
  const Bill3 = await Bills.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Bill3?.setVendor) {
    await Bill3.setVendor(relatedVendor3);
  }

  const relatedVendor4 = await Vendors.findOne({
    offset: Math.floor(Math.random() * (await Vendors.count())),
  });
  const Bill4 = await Bills.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Bill4?.setVendor) {
    await Bill4.setVendor(relatedVendor4);
  }
}

async function associateBillWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Bill0 = await Bills.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Bill0?.setOrganization) {
    await Bill0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Bill1 = await Bills.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Bill1?.setOrganization) {
    await Bill1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Bill2 = await Bills.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Bill2?.setOrganization) {
    await Bill2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Bill3 = await Bills.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Bill3?.setOrganization) {
    await Bill3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Bill4 = await Bills.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Bill4?.setOrganization) {
    await Bill4.setOrganization(relatedOrganization4);
  }
}

async function associateCandidateWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Candidate0 = await Candidates.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Candidate0?.setOrganization) {
    await Candidate0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Candidate1 = await Candidates.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Candidate1?.setOrganization) {
    await Candidate1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Candidate2 = await Candidates.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Candidate2?.setOrganization) {
    await Candidate2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Candidate3 = await Candidates.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Candidate3?.setOrganization) {
    await Candidate3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Candidate4 = await Candidates.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Candidate4?.setOrganization) {
    await Candidate4.setOrganization(relatedOrganization4);
  }
}

async function associateCardWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Card0 = await Cards.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Card0?.setEmployee) {
    await Card0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Card1 = await Cards.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Card1?.setEmployee) {
    await Card1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Card2 = await Cards.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Card2?.setEmployee) {
    await Card2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Card3 = await Cards.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Card3?.setEmployee) {
    await Card3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Card4 = await Cards.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Card4?.setEmployee) {
    await Card4.setEmployee(relatedEmployee4);
  }
}

async function associateCardWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Card0 = await Cards.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Card0?.setOrganization) {
    await Card0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Card1 = await Cards.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Card1?.setOrganization) {
    await Card1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Card2 = await Cards.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Card2?.setOrganization) {
    await Card2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Card3 = await Cards.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Card3?.setOrganization) {
    await Card3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Card4 = await Cards.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Card4?.setOrganization) {
    await Card4.setOrganization(relatedOrganization4);
  }
}

async function associateCompensationWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Compensation0 = await Compensations.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Compensation0?.setEmployee) {
    await Compensation0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Compensation1 = await Compensations.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Compensation1?.setEmployee) {
    await Compensation1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Compensation2 = await Compensations.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Compensation2?.setEmployee) {
    await Compensation2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Compensation3 = await Compensations.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Compensation3?.setEmployee) {
    await Compensation3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Compensation4 = await Compensations.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Compensation4?.setEmployee) {
    await Compensation4.setEmployee(relatedEmployee4);
  }
}

async function associateCompensationWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Compensation0 = await Compensations.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Compensation0?.setOrganization) {
    await Compensation0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Compensation1 = await Compensations.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Compensation1?.setOrganization) {
    await Compensation1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Compensation2 = await Compensations.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Compensation2?.setOrganization) {
    await Compensation2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Compensation3 = await Compensations.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Compensation3?.setOrganization) {
    await Compensation3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Compensation4 = await Compensations.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Compensation4?.setOrganization) {
    await Compensation4.setOrganization(relatedOrganization4);
  }
}

async function associateDeductionWithPayroll_run() {
  const relatedPayroll_run0 = await PayrollRuns.findOne({
    offset: Math.floor(Math.random() * (await PayrollRuns.count())),
  });
  const Deduction0 = await Deductions.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Deduction0?.setPayroll_run) {
    await Deduction0.setPayroll_run(relatedPayroll_run0);
  }

  const relatedPayroll_run1 = await PayrollRuns.findOne({
    offset: Math.floor(Math.random() * (await PayrollRuns.count())),
  });
  const Deduction1 = await Deductions.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Deduction1?.setPayroll_run) {
    await Deduction1.setPayroll_run(relatedPayroll_run1);
  }

  const relatedPayroll_run2 = await PayrollRuns.findOne({
    offset: Math.floor(Math.random() * (await PayrollRuns.count())),
  });
  const Deduction2 = await Deductions.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Deduction2?.setPayroll_run) {
    await Deduction2.setPayroll_run(relatedPayroll_run2);
  }

  const relatedPayroll_run3 = await PayrollRuns.findOne({
    offset: Math.floor(Math.random() * (await PayrollRuns.count())),
  });
  const Deduction3 = await Deductions.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Deduction3?.setPayroll_run) {
    await Deduction3.setPayroll_run(relatedPayroll_run3);
  }

  const relatedPayroll_run4 = await PayrollRuns.findOne({
    offset: Math.floor(Math.random() * (await PayrollRuns.count())),
  });
  const Deduction4 = await Deductions.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Deduction4?.setPayroll_run) {
    await Deduction4.setPayroll_run(relatedPayroll_run4);
  }
}

async function associateDeductionWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Deduction0 = await Deductions.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Deduction0?.setEmployee) {
    await Deduction0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Deduction1 = await Deductions.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Deduction1?.setEmployee) {
    await Deduction1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Deduction2 = await Deductions.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Deduction2?.setEmployee) {
    await Deduction2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Deduction3 = await Deductions.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Deduction3?.setEmployee) {
    await Deduction3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Deduction4 = await Deductions.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Deduction4?.setEmployee) {
    await Deduction4.setEmployee(relatedEmployee4);
  }
}

async function associateDeductionWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Deduction0 = await Deductions.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Deduction0?.setOrganization) {
    await Deduction0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Deduction1 = await Deductions.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Deduction1?.setOrganization) {
    await Deduction1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Deduction2 = await Deductions.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Deduction2?.setOrganization) {
    await Deduction2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Deduction3 = await Deductions.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Deduction3?.setOrganization) {
    await Deduction3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Deduction4 = await Deductions.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Deduction4?.setOrganization) {
    await Deduction4.setOrganization(relatedOrganization4);
  }
}

async function associateDeviceWithOwner() {
  const relatedOwner0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Device0 = await Devices.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Device0?.setOwner) {
    await Device0.setOwner(relatedOwner0);
  }

  const relatedOwner1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Device1 = await Devices.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Device1?.setOwner) {
    await Device1.setOwner(relatedOwner1);
  }

  const relatedOwner2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Device2 = await Devices.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Device2?.setOwner) {
    await Device2.setOwner(relatedOwner2);
  }

  const relatedOwner3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Device3 = await Devices.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Device3?.setOwner) {
    await Device3.setOwner(relatedOwner3);
  }

  const relatedOwner4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Device4 = await Devices.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Device4?.setOwner) {
    await Device4.setOwner(relatedOwner4);
  }
}

async function associateDeviceWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Device0 = await Devices.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Device0?.setOrganization) {
    await Device0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Device1 = await Devices.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Device1?.setOrganization) {
    await Device1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Device2 = await Devices.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Device2?.setOrganization) {
    await Device2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Device3 = await Devices.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Device3?.setOrganization) {
    await Device3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Device4 = await Devices.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Device4?.setOrganization) {
    await Device4.setOrganization(relatedOrganization4);
  }
}

async function associateDocumentWithOwner() {
  const relatedOwner0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Document0 = await Documents.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Document0?.setOwner) {
    await Document0.setOwner(relatedOwner0);
  }

  const relatedOwner1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Document1 = await Documents.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Document1?.setOwner) {
    await Document1.setOwner(relatedOwner1);
  }

  const relatedOwner2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Document2 = await Documents.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Document2?.setOwner) {
    await Document2.setOwner(relatedOwner2);
  }

  const relatedOwner3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Document3 = await Documents.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Document3?.setOwner) {
    await Document3.setOwner(relatedOwner3);
  }

  const relatedOwner4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Document4 = await Documents.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Document4?.setOwner) {
    await Document4.setOwner(relatedOwner4);
  }
}

async function associateDocumentWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Document0 = await Documents.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Document0?.setOrganization) {
    await Document0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Document1 = await Documents.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Document1?.setOrganization) {
    await Document1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Document2 = await Documents.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Document2?.setOrganization) {
    await Document2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Document3 = await Documents.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Document3?.setOrganization) {
    await Document3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Document4 = await Documents.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Document4?.setOrganization) {
    await Document4.setOrganization(relatedOrganization4);
  }
}

async function associateEarningWithPayroll_run() {
  const relatedPayroll_run0 = await PayrollRuns.findOne({
    offset: Math.floor(Math.random() * (await PayrollRuns.count())),
  });
  const Earning0 = await Earnings.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Earning0?.setPayroll_run) {
    await Earning0.setPayroll_run(relatedPayroll_run0);
  }

  const relatedPayroll_run1 = await PayrollRuns.findOne({
    offset: Math.floor(Math.random() * (await PayrollRuns.count())),
  });
  const Earning1 = await Earnings.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Earning1?.setPayroll_run) {
    await Earning1.setPayroll_run(relatedPayroll_run1);
  }

  const relatedPayroll_run2 = await PayrollRuns.findOne({
    offset: Math.floor(Math.random() * (await PayrollRuns.count())),
  });
  const Earning2 = await Earnings.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Earning2?.setPayroll_run) {
    await Earning2.setPayroll_run(relatedPayroll_run2);
  }

  const relatedPayroll_run3 = await PayrollRuns.findOne({
    offset: Math.floor(Math.random() * (await PayrollRuns.count())),
  });
  const Earning3 = await Earnings.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Earning3?.setPayroll_run) {
    await Earning3.setPayroll_run(relatedPayroll_run3);
  }

  const relatedPayroll_run4 = await PayrollRuns.findOne({
    offset: Math.floor(Math.random() * (await PayrollRuns.count())),
  });
  const Earning4 = await Earnings.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Earning4?.setPayroll_run) {
    await Earning4.setPayroll_run(relatedPayroll_run4);
  }
}

async function associateEarningWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Earning0 = await Earnings.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Earning0?.setEmployee) {
    await Earning0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Earning1 = await Earnings.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Earning1?.setEmployee) {
    await Earning1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Earning2 = await Earnings.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Earning2?.setEmployee) {
    await Earning2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Earning3 = await Earnings.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Earning3?.setEmployee) {
    await Earning3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Earning4 = await Earnings.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Earning4?.setEmployee) {
    await Earning4.setEmployee(relatedEmployee4);
  }
}

async function associateEarningWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Earning0 = await Earnings.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Earning0?.setOrganization) {
    await Earning0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Earning1 = await Earnings.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Earning1?.setOrganization) {
    await Earning1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Earning2 = await Earnings.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Earning2?.setOrganization) {
    await Earning2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Earning3 = await Earnings.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Earning3?.setOrganization) {
    await Earning3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Earning4 = await Earnings.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Earning4?.setOrganization) {
    await Earning4.setOrganization(relatedOrganization4);
  }
}

async function associateEmployeeWithUser() {
  const relatedUser0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Employee0 = await Employees.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Employee0?.setUser) {
    await Employee0.setUser(relatedUser0);
  }

  const relatedUser1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Employee1 = await Employees.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Employee1?.setUser) {
    await Employee1.setUser(relatedUser1);
  }

  const relatedUser2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Employee2 = await Employees.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Employee2?.setUser) {
    await Employee2.setUser(relatedUser2);
  }

  const relatedUser3 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Employee3 = await Employees.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Employee3?.setUser) {
    await Employee3.setUser(relatedUser3);
  }

  const relatedUser4 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Employee4 = await Employees.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Employee4?.setUser) {
    await Employee4.setUser(relatedUser4);
  }
}

// Similar logic for "relation_many"

// Similar logic for "relation_many"

// Similar logic for "relation_many"

// Similar logic for "relation_many"

async function associateEmployeeWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Employee0 = await Employees.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Employee0?.setOrganization) {
    await Employee0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Employee1 = await Employees.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Employee1?.setOrganization) {
    await Employee1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Employee2 = await Employees.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Employee2?.setOrganization) {
    await Employee2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Employee3 = await Employees.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Employee3?.setOrganization) {
    await Employee3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Employee4 = await Employees.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Employee4?.setOrganization) {
    await Employee4.setOrganization(relatedOrganization4);
  }
}

async function associateEmploymentWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Employment0 = await Employments.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Employment0?.setEmployee) {
    await Employment0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Employment1 = await Employments.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Employment1?.setEmployee) {
    await Employment1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Employment2 = await Employments.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Employment2?.setEmployee) {
    await Employment2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Employment3 = await Employments.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Employment3?.setEmployee) {
    await Employment3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Employment4 = await Employments.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Employment4?.setEmployee) {
    await Employment4.setEmployee(relatedEmployee4);
  }
}

async function associateEmploymentWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Employment0 = await Employments.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Employment0?.setOrganization) {
    await Employment0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Employment1 = await Employments.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Employment1?.setOrganization) {
    await Employment1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Employment2 = await Employments.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Employment2?.setOrganization) {
    await Employment2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Employment3 = await Employments.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Employment3?.setOrganization) {
    await Employment3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Employment4 = await Employments.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Employment4?.setOrganization) {
    await Employment4.setOrganization(relatedOrganization4);
  }
}

async function associateEnrollmentLearningWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const EnrollmentLearning0 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (EnrollmentLearning0?.setEmployee) {
    await EnrollmentLearning0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const EnrollmentLearning1 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (EnrollmentLearning1?.setEmployee) {
    await EnrollmentLearning1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const EnrollmentLearning2 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (EnrollmentLearning2?.setEmployee) {
    await EnrollmentLearning2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const EnrollmentLearning3 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (EnrollmentLearning3?.setEmployee) {
    await EnrollmentLearning3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const EnrollmentLearning4 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (EnrollmentLearning4?.setEmployee) {
    await EnrollmentLearning4.setEmployee(relatedEmployee4);
  }
}

async function associateEnrollmentLearningWithCourse() {
  const relatedCourse0 = await LearningCourses.findOne({
    offset: Math.floor(Math.random() * (await LearningCourses.count())),
  });
  const EnrollmentLearning0 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (EnrollmentLearning0?.setCourse) {
    await EnrollmentLearning0.setCourse(relatedCourse0);
  }

  const relatedCourse1 = await LearningCourses.findOne({
    offset: Math.floor(Math.random() * (await LearningCourses.count())),
  });
  const EnrollmentLearning1 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (EnrollmentLearning1?.setCourse) {
    await EnrollmentLearning1.setCourse(relatedCourse1);
  }

  const relatedCourse2 = await LearningCourses.findOne({
    offset: Math.floor(Math.random() * (await LearningCourses.count())),
  });
  const EnrollmentLearning2 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (EnrollmentLearning2?.setCourse) {
    await EnrollmentLearning2.setCourse(relatedCourse2);
  }

  const relatedCourse3 = await LearningCourses.findOne({
    offset: Math.floor(Math.random() * (await LearningCourses.count())),
  });
  const EnrollmentLearning3 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (EnrollmentLearning3?.setCourse) {
    await EnrollmentLearning3.setCourse(relatedCourse3);
  }

  const relatedCourse4 = await LearningCourses.findOne({
    offset: Math.floor(Math.random() * (await LearningCourses.count())),
  });
  const EnrollmentLearning4 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (EnrollmentLearning4?.setCourse) {
    await EnrollmentLearning4.setCourse(relatedCourse4);
  }
}

async function associateEnrollmentLearningWithAssigned_by() {
  const relatedAssigned_by0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const EnrollmentLearning0 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (EnrollmentLearning0?.setAssigned_by) {
    await EnrollmentLearning0.setAssigned_by(relatedAssigned_by0);
  }

  const relatedAssigned_by1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const EnrollmentLearning1 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (EnrollmentLearning1?.setAssigned_by) {
    await EnrollmentLearning1.setAssigned_by(relatedAssigned_by1);
  }

  const relatedAssigned_by2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const EnrollmentLearning2 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (EnrollmentLearning2?.setAssigned_by) {
    await EnrollmentLearning2.setAssigned_by(relatedAssigned_by2);
  }

  const relatedAssigned_by3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const EnrollmentLearning3 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (EnrollmentLearning3?.setAssigned_by) {
    await EnrollmentLearning3.setAssigned_by(relatedAssigned_by3);
  }

  const relatedAssigned_by4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const EnrollmentLearning4 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (EnrollmentLearning4?.setAssigned_by) {
    await EnrollmentLearning4.setAssigned_by(relatedAssigned_by4);
  }
}

async function associateEnrollmentLearningWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const EnrollmentLearning0 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (EnrollmentLearning0?.setOrganization) {
    await EnrollmentLearning0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const EnrollmentLearning1 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (EnrollmentLearning1?.setOrganization) {
    await EnrollmentLearning1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const EnrollmentLearning2 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (EnrollmentLearning2?.setOrganization) {
    await EnrollmentLearning2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const EnrollmentLearning3 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (EnrollmentLearning3?.setOrganization) {
    await EnrollmentLearning3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const EnrollmentLearning4 = await EnrollmentLearnings.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (EnrollmentLearning4?.setOrganization) {
    await EnrollmentLearning4.setOrganization(relatedOrganization4);
  }
}

async function associateEnrollmentWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Enrollment0 = await Enrollments.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Enrollment0?.setEmployee) {
    await Enrollment0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Enrollment1 = await Enrollments.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Enrollment1?.setEmployee) {
    await Enrollment1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Enrollment2 = await Enrollments.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Enrollment2?.setEmployee) {
    await Enrollment2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Enrollment3 = await Enrollments.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Enrollment3?.setEmployee) {
    await Enrollment3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Enrollment4 = await Enrollments.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Enrollment4?.setEmployee) {
    await Enrollment4.setEmployee(relatedEmployee4);
  }
}

async function associateEnrollmentWithPlan() {
  const relatedPlan0 = await BenefitPlans.findOne({
    offset: Math.floor(Math.random() * (await BenefitPlans.count())),
  });
  const Enrollment0 = await Enrollments.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Enrollment0?.setPlan) {
    await Enrollment0.setPlan(relatedPlan0);
  }

  const relatedPlan1 = await BenefitPlans.findOne({
    offset: Math.floor(Math.random() * (await BenefitPlans.count())),
  });
  const Enrollment1 = await Enrollments.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Enrollment1?.setPlan) {
    await Enrollment1.setPlan(relatedPlan1);
  }

  const relatedPlan2 = await BenefitPlans.findOne({
    offset: Math.floor(Math.random() * (await BenefitPlans.count())),
  });
  const Enrollment2 = await Enrollments.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Enrollment2?.setPlan) {
    await Enrollment2.setPlan(relatedPlan2);
  }

  const relatedPlan3 = await BenefitPlans.findOne({
    offset: Math.floor(Math.random() * (await BenefitPlans.count())),
  });
  const Enrollment3 = await Enrollments.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Enrollment3?.setPlan) {
    await Enrollment3.setPlan(relatedPlan3);
  }

  const relatedPlan4 = await BenefitPlans.findOne({
    offset: Math.floor(Math.random() * (await BenefitPlans.count())),
  });
  const Enrollment4 = await Enrollments.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Enrollment4?.setPlan) {
    await Enrollment4.setPlan(relatedPlan4);
  }
}

async function associateEnrollmentWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Enrollment0 = await Enrollments.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Enrollment0?.setOrganization) {
    await Enrollment0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Enrollment1 = await Enrollments.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Enrollment1?.setOrganization) {
    await Enrollment1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Enrollment2 = await Enrollments.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Enrollment2?.setOrganization) {
    await Enrollment2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Enrollment3 = await Enrollments.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Enrollment3?.setOrganization) {
    await Enrollment3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Enrollment4 = await Enrollments.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Enrollment4?.setOrganization) {
    await Enrollment4.setOrganization(relatedOrganization4);
  }
}

async function associateExpenseLineWithReport() {
  const relatedReport0 = await ExpenseReports.findOne({
    offset: Math.floor(Math.random() * (await ExpenseReports.count())),
  });
  const ExpenseLine0 = await ExpenseLines.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (ExpenseLine0?.setReport) {
    await ExpenseLine0.setReport(relatedReport0);
  }

  const relatedReport1 = await ExpenseReports.findOne({
    offset: Math.floor(Math.random() * (await ExpenseReports.count())),
  });
  const ExpenseLine1 = await ExpenseLines.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (ExpenseLine1?.setReport) {
    await ExpenseLine1.setReport(relatedReport1);
  }

  const relatedReport2 = await ExpenseReports.findOne({
    offset: Math.floor(Math.random() * (await ExpenseReports.count())),
  });
  const ExpenseLine2 = await ExpenseLines.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (ExpenseLine2?.setReport) {
    await ExpenseLine2.setReport(relatedReport2);
  }

  const relatedReport3 = await ExpenseReports.findOne({
    offset: Math.floor(Math.random() * (await ExpenseReports.count())),
  });
  const ExpenseLine3 = await ExpenseLines.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (ExpenseLine3?.setReport) {
    await ExpenseLine3.setReport(relatedReport3);
  }

  const relatedReport4 = await ExpenseReports.findOne({
    offset: Math.floor(Math.random() * (await ExpenseReports.count())),
  });
  const ExpenseLine4 = await ExpenseLines.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (ExpenseLine4?.setReport) {
    await ExpenseLine4.setReport(relatedReport4);
  }
}

async function associateExpenseLineWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ExpenseLine0 = await ExpenseLines.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (ExpenseLine0?.setOrganization) {
    await ExpenseLine0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ExpenseLine1 = await ExpenseLines.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (ExpenseLine1?.setOrganization) {
    await ExpenseLine1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ExpenseLine2 = await ExpenseLines.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (ExpenseLine2?.setOrganization) {
    await ExpenseLine2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ExpenseLine3 = await ExpenseLines.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (ExpenseLine3?.setOrganization) {
    await ExpenseLine3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ExpenseLine4 = await ExpenseLines.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (ExpenseLine4?.setOrganization) {
    await ExpenseLine4.setOrganization(relatedOrganization4);
  }
}

async function associateExpenseReportWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const ExpenseReport0 = await ExpenseReports.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (ExpenseReport0?.setEmployee) {
    await ExpenseReport0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const ExpenseReport1 = await ExpenseReports.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (ExpenseReport1?.setEmployee) {
    await ExpenseReport1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const ExpenseReport2 = await ExpenseReports.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (ExpenseReport2?.setEmployee) {
    await ExpenseReport2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const ExpenseReport3 = await ExpenseReports.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (ExpenseReport3?.setEmployee) {
    await ExpenseReport3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const ExpenseReport4 = await ExpenseReports.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (ExpenseReport4?.setEmployee) {
    await ExpenseReport4.setEmployee(relatedEmployee4);
  }
}

async function associateExpenseReportWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ExpenseReport0 = await ExpenseReports.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (ExpenseReport0?.setOrganization) {
    await ExpenseReport0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ExpenseReport1 = await ExpenseReports.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (ExpenseReport1?.setOrganization) {
    await ExpenseReport1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ExpenseReport2 = await ExpenseReports.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (ExpenseReport2?.setOrganization) {
    await ExpenseReport2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ExpenseReport3 = await ExpenseReports.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (ExpenseReport3?.setOrganization) {
    await ExpenseReport3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ExpenseReport4 = await ExpenseReports.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (ExpenseReport4?.setOrganization) {
    await ExpenseReport4.setOrganization(relatedOrganization4);
  }
}

async function associateGoalWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Goal0 = await Goals.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Goal0?.setEmployee) {
    await Goal0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Goal1 = await Goals.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Goal1?.setEmployee) {
    await Goal1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Goal2 = await Goals.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Goal2?.setEmployee) {
    await Goal2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Goal3 = await Goals.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Goal3?.setEmployee) {
    await Goal3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Goal4 = await Goals.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Goal4?.setEmployee) {
    await Goal4.setEmployee(relatedEmployee4);
  }
}

async function associateGoalWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Goal0 = await Goals.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Goal0?.setOrganization) {
    await Goal0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Goal1 = await Goals.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Goal1?.setOrganization) {
    await Goal1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Goal2 = await Goals.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Goal2?.setOrganization) {
    await Goal2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Goal3 = await Goals.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Goal3?.setOrganization) {
    await Goal3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Goal4 = await Goals.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Goal4?.setOrganization) {
    await Goal4.setOrganization(relatedOrganization4);
  }
}

async function associateIdentityAccountWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const IdentityAccount0 = await IdentityAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (IdentityAccount0?.setEmployee) {
    await IdentityAccount0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const IdentityAccount1 = await IdentityAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (IdentityAccount1?.setEmployee) {
    await IdentityAccount1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const IdentityAccount2 = await IdentityAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (IdentityAccount2?.setEmployee) {
    await IdentityAccount2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const IdentityAccount3 = await IdentityAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (IdentityAccount3?.setEmployee) {
    await IdentityAccount3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const IdentityAccount4 = await IdentityAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (IdentityAccount4?.setEmployee) {
    await IdentityAccount4.setEmployee(relatedEmployee4);
  }
}

async function associateIdentityAccountWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const IdentityAccount0 = await IdentityAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (IdentityAccount0?.setOrganization) {
    await IdentityAccount0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const IdentityAccount1 = await IdentityAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (IdentityAccount1?.setOrganization) {
    await IdentityAccount1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const IdentityAccount2 = await IdentityAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (IdentityAccount2?.setOrganization) {
    await IdentityAccount2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const IdentityAccount3 = await IdentityAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (IdentityAccount3?.setOrganization) {
    await IdentityAccount3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const IdentityAccount4 = await IdentityAccounts.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (IdentityAccount4?.setOrganization) {
    await IdentityAccount4.setOrganization(relatedOrganization4);
  }
}

async function associateInterviewWithApplication() {
  const relatedApplication0 = await Applications.findOne({
    offset: Math.floor(Math.random() * (await Applications.count())),
  });
  const Interview0 = await Interviews.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Interview0?.setApplication) {
    await Interview0.setApplication(relatedApplication0);
  }

  const relatedApplication1 = await Applications.findOne({
    offset: Math.floor(Math.random() * (await Applications.count())),
  });
  const Interview1 = await Interviews.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Interview1?.setApplication) {
    await Interview1.setApplication(relatedApplication1);
  }

  const relatedApplication2 = await Applications.findOne({
    offset: Math.floor(Math.random() * (await Applications.count())),
  });
  const Interview2 = await Interviews.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Interview2?.setApplication) {
    await Interview2.setApplication(relatedApplication2);
  }

  const relatedApplication3 = await Applications.findOne({
    offset: Math.floor(Math.random() * (await Applications.count())),
  });
  const Interview3 = await Interviews.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Interview3?.setApplication) {
    await Interview3.setApplication(relatedApplication3);
  }

  const relatedApplication4 = await Applications.findOne({
    offset: Math.floor(Math.random() * (await Applications.count())),
  });
  const Interview4 = await Interviews.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Interview4?.setApplication) {
    await Interview4.setApplication(relatedApplication4);
  }
}

async function associateInterviewWithInterviewer() {
  const relatedInterviewer0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Interview0 = await Interviews.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Interview0?.setInterviewer) {
    await Interview0.setInterviewer(relatedInterviewer0);
  }

  const relatedInterviewer1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Interview1 = await Interviews.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Interview1?.setInterviewer) {
    await Interview1.setInterviewer(relatedInterviewer1);
  }

  const relatedInterviewer2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Interview2 = await Interviews.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Interview2?.setInterviewer) {
    await Interview2.setInterviewer(relatedInterviewer2);
  }

  const relatedInterviewer3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Interview3 = await Interviews.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Interview3?.setInterviewer) {
    await Interview3.setInterviewer(relatedInterviewer3);
  }

  const relatedInterviewer4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Interview4 = await Interviews.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Interview4?.setInterviewer) {
    await Interview4.setInterviewer(relatedInterviewer4);
  }
}

async function associateInterviewWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Interview0 = await Interviews.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Interview0?.setOrganization) {
    await Interview0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Interview1 = await Interviews.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Interview1?.setOrganization) {
    await Interview1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Interview2 = await Interviews.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Interview2?.setOrganization) {
    await Interview2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Interview3 = await Interviews.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Interview3?.setOrganization) {
    await Interview3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Interview4 = await Interviews.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Interview4?.setOrganization) {
    await Interview4.setOrganization(relatedOrganization4);
  }
}

async function associateInventoryEventWithDevice() {
  const relatedDevice0 = await Devices.findOne({
    offset: Math.floor(Math.random() * (await Devices.count())),
  });
  const InventoryEvent0 = await InventoryEvents.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (InventoryEvent0?.setDevice) {
    await InventoryEvent0.setDevice(relatedDevice0);
  }

  const relatedDevice1 = await Devices.findOne({
    offset: Math.floor(Math.random() * (await Devices.count())),
  });
  const InventoryEvent1 = await InventoryEvents.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (InventoryEvent1?.setDevice) {
    await InventoryEvent1.setDevice(relatedDevice1);
  }

  const relatedDevice2 = await Devices.findOne({
    offset: Math.floor(Math.random() * (await Devices.count())),
  });
  const InventoryEvent2 = await InventoryEvents.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (InventoryEvent2?.setDevice) {
    await InventoryEvent2.setDevice(relatedDevice2);
  }

  const relatedDevice3 = await Devices.findOne({
    offset: Math.floor(Math.random() * (await Devices.count())),
  });
  const InventoryEvent3 = await InventoryEvents.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (InventoryEvent3?.setDevice) {
    await InventoryEvent3.setDevice(relatedDevice3);
  }

  const relatedDevice4 = await Devices.findOne({
    offset: Math.floor(Math.random() * (await Devices.count())),
  });
  const InventoryEvent4 = await InventoryEvents.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (InventoryEvent4?.setDevice) {
    await InventoryEvent4.setDevice(relatedDevice4);
  }
}

async function associateInventoryEventWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const InventoryEvent0 = await InventoryEvents.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (InventoryEvent0?.setOrganization) {
    await InventoryEvent0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const InventoryEvent1 = await InventoryEvents.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (InventoryEvent1?.setOrganization) {
    await InventoryEvent1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const InventoryEvent2 = await InventoryEvents.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (InventoryEvent2?.setOrganization) {
    await InventoryEvent2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const InventoryEvent3 = await InventoryEvents.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (InventoryEvent3?.setOrganization) {
    await InventoryEvent3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const InventoryEvent4 = await InventoryEvents.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (InventoryEvent4?.setOrganization) {
    await InventoryEvent4.setOrganization(relatedOrganization4);
  }
}

async function associateJobRequisitionWithRecruiter() {
  const relatedRecruiter0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const JobRequisition0 = await JobRequisitions.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (JobRequisition0?.setRecruiter) {
    await JobRequisition0.setRecruiter(relatedRecruiter0);
  }

  const relatedRecruiter1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const JobRequisition1 = await JobRequisitions.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (JobRequisition1?.setRecruiter) {
    await JobRequisition1.setRecruiter(relatedRecruiter1);
  }

  const relatedRecruiter2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const JobRequisition2 = await JobRequisitions.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (JobRequisition2?.setRecruiter) {
    await JobRequisition2.setRecruiter(relatedRecruiter2);
  }

  const relatedRecruiter3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const JobRequisition3 = await JobRequisitions.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (JobRequisition3?.setRecruiter) {
    await JobRequisition3.setRecruiter(relatedRecruiter3);
  }

  const relatedRecruiter4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const JobRequisition4 = await JobRequisitions.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (JobRequisition4?.setRecruiter) {
    await JobRequisition4.setRecruiter(relatedRecruiter4);
  }
}

async function associateJobRequisitionWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const JobRequisition0 = await JobRequisitions.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (JobRequisition0?.setOrganization) {
    await JobRequisition0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const JobRequisition1 = await JobRequisitions.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (JobRequisition1?.setOrganization) {
    await JobRequisition1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const JobRequisition2 = await JobRequisitions.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (JobRequisition2?.setOrganization) {
    await JobRequisition2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const JobRequisition3 = await JobRequisitions.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (JobRequisition3?.setOrganization) {
    await JobRequisition3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const JobRequisition4 = await JobRequisitions.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (JobRequisition4?.setOrganization) {
    await JobRequisition4.setOrganization(relatedOrganization4);
  }
}

async function associateLearningCourseWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const LearningCourse0 = await LearningCourses.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (LearningCourse0?.setOrganization) {
    await LearningCourse0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const LearningCourse1 = await LearningCourses.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (LearningCourse1?.setOrganization) {
    await LearningCourse1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const LearningCourse2 = await LearningCourses.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (LearningCourse2?.setOrganization) {
    await LearningCourse2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const LearningCourse3 = await LearningCourses.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (LearningCourse3?.setOrganization) {
    await LearningCourse3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const LearningCourse4 = await LearningCourses.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (LearningCourse4?.setOrganization) {
    await LearningCourse4.setOrganization(relatedOrganization4);
  }
}

async function associateLeaveRequestWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const LeaveRequest0 = await LeaveRequests.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (LeaveRequest0?.setEmployee) {
    await LeaveRequest0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const LeaveRequest1 = await LeaveRequests.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (LeaveRequest1?.setEmployee) {
    await LeaveRequest1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const LeaveRequest2 = await LeaveRequests.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (LeaveRequest2?.setEmployee) {
    await LeaveRequest2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const LeaveRequest3 = await LeaveRequests.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (LeaveRequest3?.setEmployee) {
    await LeaveRequest3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const LeaveRequest4 = await LeaveRequests.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (LeaveRequest4?.setEmployee) {
    await LeaveRequest4.setEmployee(relatedEmployee4);
  }
}

async function associateLeaveRequestWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const LeaveRequest0 = await LeaveRequests.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (LeaveRequest0?.setOrganization) {
    await LeaveRequest0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const LeaveRequest1 = await LeaveRequests.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (LeaveRequest1?.setOrganization) {
    await LeaveRequest1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const LeaveRequest2 = await LeaveRequests.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (LeaveRequest2?.setOrganization) {
    await LeaveRequest2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const LeaveRequest3 = await LeaveRequests.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (LeaveRequest3?.setOrganization) {
    await LeaveRequest3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const LeaveRequest4 = await LeaveRequests.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (LeaveRequest4?.setOrganization) {
    await LeaveRequest4.setOrganization(relatedOrganization4);
  }
}

async function associateOfferWithApplication() {
  const relatedApplication0 = await Applications.findOne({
    offset: Math.floor(Math.random() * (await Applications.count())),
  });
  const Offer0 = await Offers.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Offer0?.setApplication) {
    await Offer0.setApplication(relatedApplication0);
  }

  const relatedApplication1 = await Applications.findOne({
    offset: Math.floor(Math.random() * (await Applications.count())),
  });
  const Offer1 = await Offers.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Offer1?.setApplication) {
    await Offer1.setApplication(relatedApplication1);
  }

  const relatedApplication2 = await Applications.findOne({
    offset: Math.floor(Math.random() * (await Applications.count())),
  });
  const Offer2 = await Offers.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Offer2?.setApplication) {
    await Offer2.setApplication(relatedApplication2);
  }

  const relatedApplication3 = await Applications.findOne({
    offset: Math.floor(Math.random() * (await Applications.count())),
  });
  const Offer3 = await Offers.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Offer3?.setApplication) {
    await Offer3.setApplication(relatedApplication3);
  }

  const relatedApplication4 = await Applications.findOne({
    offset: Math.floor(Math.random() * (await Applications.count())),
  });
  const Offer4 = await Offers.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Offer4?.setApplication) {
    await Offer4.setApplication(relatedApplication4);
  }
}

async function associateOfferWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Offer0 = await Offers.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Offer0?.setOrganization) {
    await Offer0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Offer1 = await Offers.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Offer1?.setOrganization) {
    await Offer1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Offer2 = await Offers.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Offer2?.setOrganization) {
    await Offer2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Offer3 = await Offers.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Offer3?.setOrganization) {
    await Offer3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Offer4 = await Offers.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Offer4?.setOrganization) {
    await Offer4.setOrganization(relatedOrganization4);
  }
}

async function associatePaymentWithBill() {
  const relatedBill0 = await Bills.findOne({
    offset: Math.floor(Math.random() * (await Bills.count())),
  });
  const Payment0 = await Payments.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Payment0?.setBill) {
    await Payment0.setBill(relatedBill0);
  }

  const relatedBill1 = await Bills.findOne({
    offset: Math.floor(Math.random() * (await Bills.count())),
  });
  const Payment1 = await Payments.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Payment1?.setBill) {
    await Payment1.setBill(relatedBill1);
  }

  const relatedBill2 = await Bills.findOne({
    offset: Math.floor(Math.random() * (await Bills.count())),
  });
  const Payment2 = await Payments.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Payment2?.setBill) {
    await Payment2.setBill(relatedBill2);
  }

  const relatedBill3 = await Bills.findOne({
    offset: Math.floor(Math.random() * (await Bills.count())),
  });
  const Payment3 = await Payments.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Payment3?.setBill) {
    await Payment3.setBill(relatedBill3);
  }

  const relatedBill4 = await Bills.findOne({
    offset: Math.floor(Math.random() * (await Bills.count())),
  });
  const Payment4 = await Payments.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Payment4?.setBill) {
    await Payment4.setBill(relatedBill4);
  }
}

async function associatePaymentWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Payment0 = await Payments.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Payment0?.setOrganization) {
    await Payment0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Payment1 = await Payments.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Payment1?.setOrganization) {
    await Payment1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Payment2 = await Payments.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Payment2?.setOrganization) {
    await Payment2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Payment3 = await Payments.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Payment3?.setOrganization) {
    await Payment3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Payment4 = await Payments.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Payment4?.setOrganization) {
    await Payment4.setOrganization(relatedOrganization4);
  }
}

async function associatePayrollRunWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const PayrollRun0 = await PayrollRuns.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (PayrollRun0?.setOrganization) {
    await PayrollRun0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const PayrollRun1 = await PayrollRuns.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (PayrollRun1?.setOrganization) {
    await PayrollRun1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const PayrollRun2 = await PayrollRuns.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (PayrollRun2?.setOrganization) {
    await PayrollRun2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const PayrollRun3 = await PayrollRuns.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (PayrollRun3?.setOrganization) {
    await PayrollRun3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const PayrollRun4 = await PayrollRuns.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (PayrollRun4?.setOrganization) {
    await PayrollRun4.setOrganization(relatedOrganization4);
  }
}

async function associatePolicyWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Policy0 = await Policies.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Policy0?.setOrganization) {
    await Policy0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Policy1 = await Policies.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Policy1?.setOrganization) {
    await Policy1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Policy2 = await Policies.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Policy2?.setOrganization) {
    await Policy2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Policy3 = await Policies.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Policy3?.setOrganization) {
    await Policy3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Policy4 = await Policies.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Policy4?.setOrganization) {
    await Policy4.setOrganization(relatedOrganization4);
  }
}

async function associatePositionWithManager() {
  const relatedManager0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Position0 = await Positions.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Position0?.setManager) {
    await Position0.setManager(relatedManager0);
  }

  const relatedManager1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Position1 = await Positions.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Position1?.setManager) {
    await Position1.setManager(relatedManager1);
  }

  const relatedManager2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Position2 = await Positions.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Position2?.setManager) {
    await Position2.setManager(relatedManager2);
  }

  const relatedManager3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Position3 = await Positions.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Position3?.setManager) {
    await Position3.setManager(relatedManager3);
  }

  const relatedManager4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Position4 = await Positions.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Position4?.setManager) {
    await Position4.setManager(relatedManager4);
  }
}

async function associatePositionWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Position0 = await Positions.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Position0?.setOrganization) {
    await Position0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Position1 = await Positions.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Position1?.setOrganization) {
    await Position1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Position2 = await Positions.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Position2?.setOrganization) {
    await Position2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Position3 = await Positions.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Position3?.setOrganization) {
    await Position3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Position4 = await Positions.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Position4?.setOrganization) {
    await Position4.setOrganization(relatedOrganization4);
  }
}

async function associateReviewCycleWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ReviewCycle0 = await ReviewCycles.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (ReviewCycle0?.setOrganization) {
    await ReviewCycle0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ReviewCycle1 = await ReviewCycles.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (ReviewCycle1?.setOrganization) {
    await ReviewCycle1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ReviewCycle2 = await ReviewCycles.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (ReviewCycle2?.setOrganization) {
    await ReviewCycle2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ReviewCycle3 = await ReviewCycles.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (ReviewCycle3?.setOrganization) {
    await ReviewCycle3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ReviewCycle4 = await ReviewCycles.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (ReviewCycle4?.setOrganization) {
    await ReviewCycle4.setOrganization(relatedOrganization4);
  }
}

async function associateReviewWithReview_cycle() {
  const relatedReview_cycle0 = await ReviewCycles.findOne({
    offset: Math.floor(Math.random() * (await ReviewCycles.count())),
  });
  const Review0 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Review0?.setReview_cycle) {
    await Review0.setReview_cycle(relatedReview_cycle0);
  }

  const relatedReview_cycle1 = await ReviewCycles.findOne({
    offset: Math.floor(Math.random() * (await ReviewCycles.count())),
  });
  const Review1 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Review1?.setReview_cycle) {
    await Review1.setReview_cycle(relatedReview_cycle1);
  }

  const relatedReview_cycle2 = await ReviewCycles.findOne({
    offset: Math.floor(Math.random() * (await ReviewCycles.count())),
  });
  const Review2 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Review2?.setReview_cycle) {
    await Review2.setReview_cycle(relatedReview_cycle2);
  }

  const relatedReview_cycle3 = await ReviewCycles.findOne({
    offset: Math.floor(Math.random() * (await ReviewCycles.count())),
  });
  const Review3 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Review3?.setReview_cycle) {
    await Review3.setReview_cycle(relatedReview_cycle3);
  }

  const relatedReview_cycle4 = await ReviewCycles.findOne({
    offset: Math.floor(Math.random() * (await ReviewCycles.count())),
  });
  const Review4 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Review4?.setReview_cycle) {
    await Review4.setReview_cycle(relatedReview_cycle4);
  }
}

async function associateReviewWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Review0 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Review0?.setEmployee) {
    await Review0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Review1 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Review1?.setEmployee) {
    await Review1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Review2 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Review2?.setEmployee) {
    await Review2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Review3 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Review3?.setEmployee) {
    await Review3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Review4 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Review4?.setEmployee) {
    await Review4.setEmployee(relatedEmployee4);
  }
}

async function associateReviewWithReviewer() {
  const relatedReviewer0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Review0 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Review0?.setReviewer) {
    await Review0.setReviewer(relatedReviewer0);
  }

  const relatedReviewer1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Review1 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Review1?.setReviewer) {
    await Review1.setReviewer(relatedReviewer1);
  }

  const relatedReviewer2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Review2 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Review2?.setReviewer) {
    await Review2.setReviewer(relatedReviewer2);
  }

  const relatedReviewer3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Review3 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Review3?.setReviewer) {
    await Review3.setReviewer(relatedReviewer3);
  }

  const relatedReviewer4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Review4 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Review4?.setReviewer) {
    await Review4.setReviewer(relatedReviewer4);
  }
}

async function associateReviewWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Review0 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Review0?.setOrganization) {
    await Review0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Review1 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Review1?.setOrganization) {
    await Review1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Review2 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Review2?.setOrganization) {
    await Review2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Review3 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Review3?.setOrganization) {
    await Review3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Review4 = await Reviews.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Review4?.setOrganization) {
    await Review4.setOrganization(relatedOrganization4);
  }
}

async function associateScheduleShiftWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const ScheduleShift0 = await ScheduleShifts.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (ScheduleShift0?.setEmployee) {
    await ScheduleShift0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const ScheduleShift1 = await ScheduleShifts.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (ScheduleShift1?.setEmployee) {
    await ScheduleShift1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const ScheduleShift2 = await ScheduleShifts.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (ScheduleShift2?.setEmployee) {
    await ScheduleShift2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const ScheduleShift3 = await ScheduleShifts.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (ScheduleShift3?.setEmployee) {
    await ScheduleShift3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const ScheduleShift4 = await ScheduleShifts.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (ScheduleShift4?.setEmployee) {
    await ScheduleShift4.setEmployee(relatedEmployee4);
  }
}

async function associateScheduleShiftWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ScheduleShift0 = await ScheduleShifts.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (ScheduleShift0?.setOrganization) {
    await ScheduleShift0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ScheduleShift1 = await ScheduleShifts.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (ScheduleShift1?.setOrganization) {
    await ScheduleShift1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ScheduleShift2 = await ScheduleShifts.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (ScheduleShift2?.setOrganization) {
    await ScheduleShift2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ScheduleShift3 = await ScheduleShifts.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (ScheduleShift3?.setOrganization) {
    await ScheduleShift3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const ScheduleShift4 = await ScheduleShifts.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (ScheduleShift4?.setOrganization) {
    await ScheduleShift4.setOrganization(relatedOrganization4);
  }
}

async function associateTaxWithPayroll_run() {
  const relatedPayroll_run0 = await PayrollRuns.findOne({
    offset: Math.floor(Math.random() * (await PayrollRuns.count())),
  });
  const Tax0 = await Taxes.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Tax0?.setPayroll_run) {
    await Tax0.setPayroll_run(relatedPayroll_run0);
  }

  const relatedPayroll_run1 = await PayrollRuns.findOne({
    offset: Math.floor(Math.random() * (await PayrollRuns.count())),
  });
  const Tax1 = await Taxes.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Tax1?.setPayroll_run) {
    await Tax1.setPayroll_run(relatedPayroll_run1);
  }

  const relatedPayroll_run2 = await PayrollRuns.findOne({
    offset: Math.floor(Math.random() * (await PayrollRuns.count())),
  });
  const Tax2 = await Taxes.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Tax2?.setPayroll_run) {
    await Tax2.setPayroll_run(relatedPayroll_run2);
  }

  const relatedPayroll_run3 = await PayrollRuns.findOne({
    offset: Math.floor(Math.random() * (await PayrollRuns.count())),
  });
  const Tax3 = await Taxes.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Tax3?.setPayroll_run) {
    await Tax3.setPayroll_run(relatedPayroll_run3);
  }

  const relatedPayroll_run4 = await PayrollRuns.findOne({
    offset: Math.floor(Math.random() * (await PayrollRuns.count())),
  });
  const Tax4 = await Taxes.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Tax4?.setPayroll_run) {
    await Tax4.setPayroll_run(relatedPayroll_run4);
  }
}

async function associateTaxWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Tax0 = await Taxes.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Tax0?.setEmployee) {
    await Tax0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Tax1 = await Taxes.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Tax1?.setEmployee) {
    await Tax1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Tax2 = await Taxes.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Tax2?.setEmployee) {
    await Tax2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Tax3 = await Taxes.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Tax3?.setEmployee) {
    await Tax3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Tax4 = await Taxes.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Tax4?.setEmployee) {
    await Tax4.setEmployee(relatedEmployee4);
  }
}

async function associateTaxWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Tax0 = await Taxes.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Tax0?.setOrganization) {
    await Tax0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Tax1 = await Taxes.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Tax1?.setOrganization) {
    await Tax1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Tax2 = await Taxes.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Tax2?.setOrganization) {
    await Tax2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Tax3 = await Taxes.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Tax3?.setOrganization) {
    await Tax3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Tax4 = await Taxes.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Tax4?.setOrganization) {
    await Tax4.setOrganization(relatedOrganization4);
  }
}

async function associateTimeEntryWithTimecard() {
  const relatedTimecard0 = await Timecards.findOne({
    offset: Math.floor(Math.random() * (await Timecards.count())),
  });
  const TimeEntry0 = await TimeEntries.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (TimeEntry0?.setTimecard) {
    await TimeEntry0.setTimecard(relatedTimecard0);
  }

  const relatedTimecard1 = await Timecards.findOne({
    offset: Math.floor(Math.random() * (await Timecards.count())),
  });
  const TimeEntry1 = await TimeEntries.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (TimeEntry1?.setTimecard) {
    await TimeEntry1.setTimecard(relatedTimecard1);
  }

  const relatedTimecard2 = await Timecards.findOne({
    offset: Math.floor(Math.random() * (await Timecards.count())),
  });
  const TimeEntry2 = await TimeEntries.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (TimeEntry2?.setTimecard) {
    await TimeEntry2.setTimecard(relatedTimecard2);
  }

  const relatedTimecard3 = await Timecards.findOne({
    offset: Math.floor(Math.random() * (await Timecards.count())),
  });
  const TimeEntry3 = await TimeEntries.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (TimeEntry3?.setTimecard) {
    await TimeEntry3.setTimecard(relatedTimecard3);
  }

  const relatedTimecard4 = await Timecards.findOne({
    offset: Math.floor(Math.random() * (await Timecards.count())),
  });
  const TimeEntry4 = await TimeEntries.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (TimeEntry4?.setTimecard) {
    await TimeEntry4.setTimecard(relatedTimecard4);
  }
}

async function associateTimeEntryWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const TimeEntry0 = await TimeEntries.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (TimeEntry0?.setOrganization) {
    await TimeEntry0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const TimeEntry1 = await TimeEntries.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (TimeEntry1?.setOrganization) {
    await TimeEntry1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const TimeEntry2 = await TimeEntries.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (TimeEntry2?.setOrganization) {
    await TimeEntry2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const TimeEntry3 = await TimeEntries.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (TimeEntry3?.setOrganization) {
    await TimeEntry3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const TimeEntry4 = await TimeEntries.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (TimeEntry4?.setOrganization) {
    await TimeEntry4.setOrganization(relatedOrganization4);
  }
}

async function associateTimecardWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Timecard0 = await Timecards.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Timecard0?.setEmployee) {
    await Timecard0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Timecard1 = await Timecards.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Timecard1?.setEmployee) {
    await Timecard1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Timecard2 = await Timecards.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Timecard2?.setEmployee) {
    await Timecard2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Timecard3 = await Timecards.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Timecard3?.setEmployee) {
    await Timecard3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const Timecard4 = await Timecards.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Timecard4?.setEmployee) {
    await Timecard4.setEmployee(relatedEmployee4);
  }
}

async function associateTimecardWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Timecard0 = await Timecards.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Timecard0?.setOrganization) {
    await Timecard0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Timecard1 = await Timecards.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Timecard1?.setOrganization) {
    await Timecard1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Timecard2 = await Timecards.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Timecard2?.setOrganization) {
    await Timecard2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Timecard3 = await Timecards.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Timecard3?.setOrganization) {
    await Timecard3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Timecard4 = await Timecards.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Timecard4?.setOrganization) {
    await Timecard4.setOrganization(relatedOrganization4);
  }
}

async function associateTravelBookingWithEmployee() {
  const relatedEmployee0 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const TravelBooking0 = await TravelBookings.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (TravelBooking0?.setEmployee) {
    await TravelBooking0.setEmployee(relatedEmployee0);
  }

  const relatedEmployee1 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const TravelBooking1 = await TravelBookings.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (TravelBooking1?.setEmployee) {
    await TravelBooking1.setEmployee(relatedEmployee1);
  }

  const relatedEmployee2 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const TravelBooking2 = await TravelBookings.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (TravelBooking2?.setEmployee) {
    await TravelBooking2.setEmployee(relatedEmployee2);
  }

  const relatedEmployee3 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const TravelBooking3 = await TravelBookings.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (TravelBooking3?.setEmployee) {
    await TravelBooking3.setEmployee(relatedEmployee3);
  }

  const relatedEmployee4 = await Employees.findOne({
    offset: Math.floor(Math.random() * (await Employees.count())),
  });
  const TravelBooking4 = await TravelBookings.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (TravelBooking4?.setEmployee) {
    await TravelBooking4.setEmployee(relatedEmployee4);
  }
}

async function associateTravelBookingWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const TravelBooking0 = await TravelBookings.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (TravelBooking0?.setOrganization) {
    await TravelBooking0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const TravelBooking1 = await TravelBookings.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (TravelBooking1?.setOrganization) {
    await TravelBooking1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const TravelBooking2 = await TravelBookings.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (TravelBooking2?.setOrganization) {
    await TravelBooking2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const TravelBooking3 = await TravelBookings.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (TravelBooking3?.setOrganization) {
    await TravelBooking3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const TravelBooking4 = await TravelBookings.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (TravelBooking4?.setOrganization) {
    await TravelBooking4.setOrganization(relatedOrganization4);
  }
}

async function associateVendorWithOrganization() {
  const relatedOrganization0 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Vendor0 = await Vendors.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Vendor0?.setOrganization) {
    await Vendor0.setOrganization(relatedOrganization0);
  }

  const relatedOrganization1 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Vendor1 = await Vendors.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Vendor1?.setOrganization) {
    await Vendor1.setOrganization(relatedOrganization1);
  }

  const relatedOrganization2 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Vendor2 = await Vendors.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Vendor2?.setOrganization) {
    await Vendor2.setOrganization(relatedOrganization2);
  }

  const relatedOrganization3 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Vendor3 = await Vendors.findOne({
    order: [['id', 'ASC']],
    offset: 3,
  });
  if (Vendor3?.setOrganization) {
    await Vendor3.setOrganization(relatedOrganization3);
  }

  const relatedOrganization4 = await Organizations.findOne({
    offset: Math.floor(Math.random() * (await Organizations.count())),
  });
  const Vendor4 = await Vendors.findOne({
    order: [['id', 'ASC']],
    offset: 4,
  });
  if (Vendor4?.setOrganization) {
    await Vendor4.setOrganization(relatedOrganization4);
  }
}

module.exports = {
  up: async (queryInterface, Sequelize) => {
    await AppAccounts.bulkCreate(AppAccountsData);

    await Applications.bulkCreate(ApplicationsData);

    await Approvals.bulkCreate(ApprovalsData);

    await AuditLogs.bulkCreate(AuditLogsData);

    await BenefitPlans.bulkCreate(BenefitPlansData);

    await Bills.bulkCreate(BillsData);

    await Candidates.bulkCreate(CandidatesData);

    await Cards.bulkCreate(CardsData);

    await Compensations.bulkCreate(CompensationsData);

    await Deductions.bulkCreate(DeductionsData);

    await Devices.bulkCreate(DevicesData);

    await Documents.bulkCreate(DocumentsData);

    await Earnings.bulkCreate(EarningsData);

    await Employees.bulkCreate(EmployeesData);

    await Employments.bulkCreate(EmploymentsData);

    await EnrollmentLearnings.bulkCreate(EnrollmentLearningsData);

    await Enrollments.bulkCreate(EnrollmentsData);

    await ExpenseLines.bulkCreate(ExpenseLinesData);

    await ExpenseReports.bulkCreate(ExpenseReportsData);

    await Goals.bulkCreate(GoalsData);

    await IdentityAccounts.bulkCreate(IdentityAccountsData);

    await Interviews.bulkCreate(InterviewsData);

    await InventoryEvents.bulkCreate(InventoryEventsData);

    await JobRequisitions.bulkCreate(JobRequisitionsData);

    await LearningCourses.bulkCreate(LearningCoursesData);

    await LeaveRequests.bulkCreate(LeaveRequestsData);

    await Offers.bulkCreate(OffersData);

    await Payments.bulkCreate(PaymentsData);

    await PayrollRuns.bulkCreate(PayrollRunsData);

    await Policies.bulkCreate(PoliciesData);

    await Positions.bulkCreate(PositionsData);

    await ReviewCycles.bulkCreate(ReviewCyclesData);

    await Reviews.bulkCreate(ReviewsData);

    await ScheduleShifts.bulkCreate(ScheduleShiftsData);

    await Taxes.bulkCreate(TaxesData);

    await TimeEntries.bulkCreate(TimeEntriesData);

    await Timecards.bulkCreate(TimecardsData);

    await TravelBookings.bulkCreate(TravelBookingsData);

    await Vendors.bulkCreate(VendorsData);

    await Organizations.bulkCreate(OrganizationsData);

    await Promise.all([
      // Similar logic for "relation_many"

      await associateUserWithOrganization(),

      await associateAppAccountWithEmployee(),

      await associateAppAccountWithOrganization(),

      await associateApplicationWithCandidate(),

      await associateApplicationWithRequisition(),

      await associateApplicationWithOrganization(),

      await associateApprovalWithApprover(),

      await associateApprovalWithOrganization(),

      await associateAuditLogWithOrganization(),

      await associateBenefitPlanWithOrganization(),

      await associateBillWithVendor(),

      await associateBillWithOrganization(),

      await associateCandidateWithOrganization(),

      await associateCardWithEmployee(),

      await associateCardWithOrganization(),

      await associateCompensationWithEmployee(),

      await associateCompensationWithOrganization(),

      await associateDeductionWithPayroll_run(),

      await associateDeductionWithEmployee(),

      await associateDeductionWithOrganization(),

      await associateDeviceWithOwner(),

      await associateDeviceWithOrganization(),

      await associateDocumentWithOwner(),

      await associateDocumentWithOrganization(),

      await associateEarningWithPayroll_run(),

      await associateEarningWithEmployee(),

      await associateEarningWithOrganization(),

      await associateEmployeeWithUser(),

      // Similar logic for "relation_many"

      // Similar logic for "relation_many"

      // Similar logic for "relation_many"

      // Similar logic for "relation_many"

      await associateEmployeeWithOrganization(),

      await associateEmploymentWithEmployee(),

      await associateEmploymentWithOrganization(),

      await associateEnrollmentLearningWithEmployee(),

      await associateEnrollmentLearningWithCourse(),

      await associateEnrollmentLearningWithAssigned_by(),

      await associateEnrollmentLearningWithOrganization(),

      await associateEnrollmentWithEmployee(),

      await associateEnrollmentWithPlan(),

      await associateEnrollmentWithOrganization(),

      await associateExpenseLineWithReport(),

      await associateExpenseLineWithOrganization(),

      await associateExpenseReportWithEmployee(),

      await associateExpenseReportWithOrganization(),

      await associateGoalWithEmployee(),

      await associateGoalWithOrganization(),

      await associateIdentityAccountWithEmployee(),

      await associateIdentityAccountWithOrganization(),

      await associateInterviewWithApplication(),

      await associateInterviewWithInterviewer(),

      await associateInterviewWithOrganization(),

      await associateInventoryEventWithDevice(),

      await associateInventoryEventWithOrganization(),

      await associateJobRequisitionWithRecruiter(),

      await associateJobRequisitionWithOrganization(),

      await associateLearningCourseWithOrganization(),

      await associateLeaveRequestWithEmployee(),

      await associateLeaveRequestWithOrganization(),

      await associateOfferWithApplication(),

      await associateOfferWithOrganization(),

      await associatePaymentWithBill(),

      await associatePaymentWithOrganization(),

      await associatePayrollRunWithOrganization(),

      await associatePolicyWithOrganization(),

      await associatePositionWithManager(),

      await associatePositionWithOrganization(),

      await associateReviewCycleWithOrganization(),

      await associateReviewWithReview_cycle(),

      await associateReviewWithEmployee(),

      await associateReviewWithReviewer(),

      await associateReviewWithOrganization(),

      await associateScheduleShiftWithEmployee(),

      await associateScheduleShiftWithOrganization(),

      await associateTaxWithPayroll_run(),

      await associateTaxWithEmployee(),

      await associateTaxWithOrganization(),

      await associateTimeEntryWithTimecard(),

      await associateTimeEntryWithOrganization(),

      await associateTimecardWithEmployee(),

      await associateTimecardWithOrganization(),

      await associateTravelBookingWithEmployee(),

      await associateTravelBookingWithOrganization(),

      await associateVendorWithOrganization(),
    ]);
  },

  down: async (queryInterface, Sequelize) => {
    await queryInterface.bulkDelete('app_accounts', null, {});

    await queryInterface.bulkDelete('applications', null, {});

    await queryInterface.bulkDelete('approvals', null, {});

    await queryInterface.bulkDelete('audit_logs', null, {});

    await queryInterface.bulkDelete('benefit_plans', null, {});

    await queryInterface.bulkDelete('bills', null, {});

    await queryInterface.bulkDelete('candidates', null, {});

    await queryInterface.bulkDelete('cards', null, {});

    await queryInterface.bulkDelete('compensations', null, {});

    await queryInterface.bulkDelete('deductions', null, {});

    await queryInterface.bulkDelete('devices', null, {});

    await queryInterface.bulkDelete('documents', null, {});

    await queryInterface.bulkDelete('earnings', null, {});

    await queryInterface.bulkDelete('employees', null, {});

    await queryInterface.bulkDelete('employments', null, {});

    await queryInterface.bulkDelete('enrollment_learnings', null, {});

    await queryInterface.bulkDelete('enrollments', null, {});

    await queryInterface.bulkDelete('expense_lines', null, {});

    await queryInterface.bulkDelete('expense_reports', null, {});

    await queryInterface.bulkDelete('goals', null, {});

    await queryInterface.bulkDelete('identity_accounts', null, {});

    await queryInterface.bulkDelete('interviews', null, {});

    await queryInterface.bulkDelete('inventory_events', null, {});

    await queryInterface.bulkDelete('job_requisitions', null, {});

    await queryInterface.bulkDelete('learning_courses', null, {});

    await queryInterface.bulkDelete('leave_requests', null, {});

    await queryInterface.bulkDelete('offers', null, {});

    await queryInterface.bulkDelete('payments', null, {});

    await queryInterface.bulkDelete('payroll_runs', null, {});

    await queryInterface.bulkDelete('policies', null, {});

    await queryInterface.bulkDelete('positions', null, {});

    await queryInterface.bulkDelete('review_cycles', null, {});

    await queryInterface.bulkDelete('reviews', null, {});

    await queryInterface.bulkDelete('schedule_shifts', null, {});

    await queryInterface.bulkDelete('taxes', null, {});

    await queryInterface.bulkDelete('time_entries', null, {});

    await queryInterface.bulkDelete('timecards', null, {});

    await queryInterface.bulkDelete('travel_bookings', null, {});

    await queryInterface.bulkDelete('vendors', null, {});

    await queryInterface.bulkDelete('organizations', null, {});
  },
};
