/**
 * Models Index
 * Dynamically loads real or mock models based on database mode
 */

import mongoose, { Model, Schema } from 'mongoose';
import { isMockMode, mockDB } from '../utils/database';

// ============================================
// MOCK MODEL IMPLEMENTATION
// ============================================

/**
 * Creates a mock model that behaves like a Mongoose model constructor.
 * Supports `new Model(data)` + `.save()`, `Model.create(data)`,
 * `Model.findOne()`, `Model.find()`, `Model.findById()`, `Model.findByIdAndDelete()`.
 * `Model.find()` returns a chainable query supporting `.select()`, `.sort()`, `.lean()`.
 */

/**
 * Project a plain object per a Mongoose-style select() token list.
 * Handles `field` (include only), `-field` (exclude), and `+field` (include an
 * otherwise-hidden `select:false` field). Because mock documents store every
 * field, a select made up ONLY of `+`/`-` tokens keeps the full document —
 * matching Mongoose, where `+field` ADDS a hidden field to the default full
 * projection rather than restricting to it. (The previous implementation
 * treated `+encryptedX` as a literal field name, which matched nothing and
 * silently stripped every encrypted credential — breaking config read-back in
 * mock mode.)
 */
function projectSelect(item: any, tokens: string[]): any {
  if (!tokens || tokens.length === 0) return item;
  const excludes = tokens.filter((t) => t.startsWith('-')).map((t) => t.slice(1));
  const plusIncludes = tokens.filter((t) => t.startsWith('+')).map((t) => t.slice(1));
  const plainIncludes = tokens.filter((t) => !t.startsWith('+') && !t.startsWith('-'));

  // Exclusion / additive-only mode → keep the whole document minus excludes.
  if (plainIncludes.length === 0) {
    if (excludes.length === 0) return { ...item };
    const out: any = {};
    for (const [key, val] of Object.entries(item)) {
      if (typeof val === 'function') continue;
      if (!excludes.includes(key)) out[key] = val;
    }
    return out;
  }

  // Inclusion mode → only the named fields (plain + any `+` hidden fields), + ids.
  const include = new Set([...plainIncludes, ...plusIncludes]);
  const out: any = {};
  for (const key of include) {
    if (key in item) out[key] = item[key];
  }
  if (item._id !== undefined) out._id = item._id;
  if (item.id !== undefined) out.id = item.id;
  return out;
}

/**
 * Mock query chain that mimics Mongoose Query for .find().select().sort().lean().
 * Each chaining method returns `this` so calls can be chained.
 * The query is executed when `await`ed (thenable) or when `.then()`/`.catch()` is called.
 */
class MockQuery {
  private _items: any[];
  private _selectFields: Set<string> | null = null;
  private _sortSpec: Record<string, 1 | -1> | null = null;
  private _limit: number | null = null;
  private _skip: number | null = null;
  private _addMethods: (item: any) => any;

  constructor(items: any[], addMethods: (item: any) => any) {
    this._items = items;
    this._addMethods = addMethods;
  }

  /** Select specific fields to include in results (space-separated or object).
   *  Supports exclusion with `-` prefix, e.g. `.select('-passwordHash')` */
  select(fields: string | Record<string, number>): this {
    if (typeof fields === 'string') {
      // Keep +/- prefixes; projectSelect interprets them.
      this._selectFields = new Set(fields.split(/\s+/).filter(Boolean));
    } else if (typeof fields === 'object' && fields !== null) {
      // Object form: { name: 1 } → 'name'; { passwordHash: 0 } → '-passwordHash'.
      // Normalise to prefixed string tokens so projectSelect handles it uniformly.
      const tokens = new Set<string>();
      for (const [key, val] of Object.entries(fields)) {
        tokens.add(val ? key : `-${key}`);
      }
      this._selectFields = tokens;
    }
    return this;
  }

  /** Sort results. Accepts an object like { updatedAt: -1 } or a string like "-updatedAt". */
  sort(spec: Record<string, 1 | -1> | string): this {
    if (typeof spec === 'object' && spec !== null) {
      this._sortSpec = spec;
    } else if (typeof spec === 'string') {
      // Parse "-updatedAt" → { updatedAt: -1 }
      this._sortSpec = {};
      const parts = spec.trim().split(/\s+/);
      for (const part of parts) {
        if (part.startsWith('-')) {
          (this._sortSpec as Record<string, 1 | -1>)[part.slice(1)] = -1;
        } else {
          (this._sortSpec as Record<string, 1 | -1>)[part] = 1;
        }
      }
    }
    return this;
  }

  /** Limit the number of results. */
  limit(n: number): this {
    this._limit = n;
    return this;
  }

  /** Skip a number of results (for pagination). */
  skip(n: number): this {
    this._skip = n;
    return this;
  }

  /** Return plain objects instead of Mongoose documents (no-op in mock). */
  lean(): this {
    return this;
  }

  /** Execute the query and return results. */
  private _execute(): any[] {
    let results = this._items.map((item: any) => this._addMethods({ ...item }));

    // Apply sorting
    if (this._sortSpec) {
      const sortEntries = Object.entries(this._sortSpec);
      results.sort((a: any, b: any) => {
        for (const [key, order] of sortEntries) {
          const aVal = a[key];
          const bVal = b[key];
          if (aVal == null && bVal == null) continue;
          if (aVal == null) return order;
          if (bVal == null) return -order;
          const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
          if (cmp !== 0) return cmp * order;
        }
        return 0;
      });
    }

    // Apply field selection (handles include / -exclude / +hidden uniformly)
    if (this._selectFields) {
      const tokens = Array.from(this._selectFields);
      results = results.map((item: any) => projectSelect(item, tokens));
    }

    // Apply skip (pagination offset)
    if (this._skip != null) {
      results = results.slice(this._skip);
    }

    // Apply limit
    if (this._limit != null) {
      results = results.slice(0, this._limit);
    }

    return results;
  }

  // Thenable — makes `await mockQuery` work
  then(resolve: (value: any) => void, reject?: (reason?: any) => void): void {
    try {
      resolve(this._execute());
    } catch (err) {
      reject?.(err);
    }
  }

  catch(reject: (reason?: any) => void): void {
    // Errors won't occur in mock execution, but satisfy the interface
  }
}

function createMockModel<T extends Record<string, any>>(name: string) {
  const collection = new Map<string, any>();

  function Model(data: Record<string, any>) {
    const id = Math.random().toString(36).substring(2, 15);
    // Auto-lowercase email to match Mongoose schema behaviour (lowercase: true)
    if (data.email && typeof data.email === 'string') {
      data.email = data.email.toLowerCase();
    }
    const item: any = {
      ...data,
      _id: id,
      id,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };
    collection.set(id, item);
    addMethods(item);
    return item;
  }

  function addMethods(item: any): any {
    // Always overwrite save so it syncs changes back to the collection
    item.save = async () => {
      item.updatedAt = new Date().toISOString();
      // Auto-lowercase email on save to match Mongoose schema behaviour (lowercase: true)
      if (item.email && typeof item.email === 'string') {
        item.email = item.email.toLowerCase();
      }
      // Sync shallow copy back to the collection so mutations persist
      if (item.id && collection.has(item.id)) {
        collection.set(item.id, { ...item });
      }
      return item;
    };
    if (!item.comparePassword && item.passwordHash) {
      item.comparePassword = async (password: string) => {
        return mockDB.comparePassword(password, item.passwordHash);
      };
    }
    return item;
  }

  /** Helper: test if a value matches a condition (exact, $regex, $in, $ne, $exists) */
  const matchesCondition = (itemVal: any, condition: any): boolean => {
    if (condition && typeof condition === 'object' && !Array.isArray(condition)) {
      // $regex support — condition.$regex can be a RegExp or a string pattern
      if (condition.$regex) {
        const regex = condition.$regex instanceof RegExp
          ? condition.$regex
          : new RegExp(condition.$regex, condition.$options || '');
        if (!regex.test(itemVal)) return false;
      }
      // $in support
      if (condition.$in) {
        if (!Array.isArray(condition.$in) || !condition.$in.includes(itemVal)) return false;
      }
      // $ne support
      if ('$ne' in condition) {
        if (itemVal === condition.$ne) return false;
      }
      // $exists support
      if ('$exists' in condition) {
        const exists = itemVal !== undefined && itemVal !== null;
        if (condition.$exists && !exists) return false;
        if (!condition.$exists && exists) return false;
      }
      // $gt, $gte, $lt, $lte support
      if (condition.$gt != null && !(itemVal > condition.$gt)) return false;
      if (condition.$gte != null && !(itemVal >= condition.$gte)) return false;
      if (condition.$lt != null && !(itemVal < condition.$lt)) return false;
      if (condition.$lte != null && !(itemVal <= condition.$lte)) return false;
      return true; // all specified operators passed
    }
    // Array field vs scalar: Mongoose matches when ANY element equals the value
    // (e.g. `{ companyIds: 'abc' }` matches a user whose companyIds contains it).
    // Without this, every membership query silently returned nothing in mock mode.
    if (Array.isArray(itemVal)) {
      return itemVal.includes(condition);
    }
    // Exact match (including null/undefined)
    return itemVal === condition;
  };

  /** Helper: test if an item matches a full query filter including $or */
  const matchesQuery = (item: any, query: Record<string, any>): boolean => {
    for (const [key, condition] of Object.entries(query)) {
      if (key === '$or') {
        // $or: at least one sub-condition must match
        if (!Array.isArray(condition) || !condition.some((sub: any) => matchesQuery(item, sub))) {
          return false;
        }
      } else if (key === '$and') {
        // $and: all sub-conditions must match
        if (!Array.isArray(condition) || !condition.every((sub: any) => matchesQuery(item, sub))) {
          return false;
        }
      } else if (key === '_id') {
        // _id: handle { $in: [...] } or plain value
        const id = item.id || item._id;
        if (condition && typeof condition === 'object' && condition.$in) {
          if (!condition.$in.includes(id)) return false;
        } else {
          if (id !== condition) return false;
        }
      } else {
        if (!matchesCondition(item[key], condition)) return false;
      }
    }
    return true;
  };

  Model.findOne = (query: Record<string, any>): any => {
    // Returns a thenable that also supports .lean() chaining
    const result = (() => {
      for (const item of collection.values()) {
        if (matchesQuery(item, query)) {
          return addMethods({ ...item });
        }
      }
      return null;
    })();

    // Create a thenable object that supports .lean(), .select() and .sort() chaining
    const thenable: any = {
      then: (resolve: (value: any) => void, reject?: (reason?: any) => void) => {
        // Apply select/lean transformations to the result
        let finalResult = result;
        if (finalResult && thenable._selectFields) {
          finalResult = projectSelect(finalResult, thenable._selectFields);
        }
        // .lean() is a no-op for mock — we already return plain objects
        resolve(finalResult);
      },
      catch: (reject?: (reason?: any) => void) => { /* no-op */ },
      lean: () => thenable,
      // .sort() is accepted for chaining parity with Mongoose (findOne already
      // returns the first match; ordering is a no-op for a single result).
      sort: () => thenable,
      select: (fields: string | Record<string, number>) => {
        if (typeof fields === 'string') {
          thenable._selectFields = fields.split(/\s+/).filter(Boolean);
        }
        return thenable;
      },
      _selectFields: null as string[] | null,
    };
    return thenable;
  };

  Model.find = (query?: any): any => {
    let items = Array.from(collection.values());
    if (query) {
      items = items.filter((item: any) => matchesQuery(item, query));
    }
    // Return chainable MockQuery instead of a plain array
    return new MockQuery(items, addMethods);
  };

  Model.findById = (id: string): any => {
    // Returns a thenable that supports .select() and .lean() chaining
    const item = collection.get(id);
    const result = item ? addMethods({ ...item }) : null;

    const thenable: any = {
      then: (resolve: (value: any) => void, reject?: (reason?: any) => void) => {
        let finalResult = result;
        if (finalResult && thenable._selectFields) {
          finalResult = projectSelect(finalResult, thenable._selectFields);
        }
        resolve(finalResult);
      },
      catch: (reject?: (reason?: any) => void) => { /* no-op */ },
      lean: () => thenable,
      sort: () => thenable,
      select: (fields: string | Record<string, number>) => {
        if (typeof fields === 'string') {
          thenable._selectFields = fields.split(/\s+/).filter(Boolean);
        }
        return thenable;
      },
      _selectFields: null as string[] | null,
    };
    return thenable;
  };

  Model.findByIdAndDelete = async (id: string): Promise<any> => {
    const item = collection.get(id);
    collection.delete(id);
    return item || null;
  };

  Model.create = (data: Record<string, any>): any => {
    return Model(data);
  };

  /**
   * Bulk insert. Mirrors the subset of Mongoose the notification fan-out uses
   * (`insertMany(docs, { ordered: false })`) — without this the method simply
   * did not exist on a mock model, so any bulk write threw in mock mode.
   */
  Model.insertMany = async (docs: Record<string, any>[], _options?: any): Promise<any[]> => {
    return (Array.isArray(docs) ? docs : [docs]).map((doc) => Model(doc));
  };

  Model.findByIdAndUpdate = async (id: string, update: any, options?: any): Promise<any | null> => {
    const item = collection.get(id);
    if (!item) return null;
    Object.assign(item, update, { updatedAt: new Date().toISOString() });
    return addMethods(item);
  };

  /**
   * findOneAndUpdate with upsert support. Mirrors the subset of Mongoose used by
   * the OAuth connect flows (YouTube/Facebook/Instagram store connected accounts
   * via findOneAndUpdate({...}, {...}, { upsert: true, new: true })). Previously
   * this method did not exist on the mock model, so those callbacks threw and no
   * account was ever saved in mock mode.
   */
  Model.findOneAndUpdate = async (filter: Record<string, any>, update: any, options?: any): Promise<any | null> => {
    // Apply $set + plain top-level fields (the flows pass a plain object, no operators)
    const applyUpdate = (target: any) => {
      for (const [key, val] of Object.entries(update || {})) {
        if (key === '$set' && val && typeof val === 'object') {
          Object.assign(target, val);
        } else if (!key.startsWith('$')) {
          target[key] = val;
        }
      }
      target.updatedAt = new Date().toISOString();
    };

    for (const [, item] of collection.entries()) {
      if (matchesQuery(item, filter)) {
        applyUpdate(item);
        return addMethods(item);
      }
    }

    if (options?.upsert) {
      // Seed from the filter's equality fields, then apply the update
      const seed: any = {};
      for (const [key, val] of Object.entries(filter)) {
        if (!key.startsWith('$') && (typeof val !== 'object' || val === null)) seed[key] = val;
      }
      const created = Model(seed);
      applyUpdate(created);
      if (created.id && collection.has(created.id)) collection.set(created.id, { ...created });
      return addMethods(created);
    }

    return null;
  };

  Model.deleteOne = async (query: Record<string, any>): Promise<void> => {
    for (const [id, item] of collection.entries()) {
      if (matchesQuery(item, query)) {
        collection.delete(id);
        return;
      }
    }
  };

  // ── updateMany / deleteMany — cascade support for mock models ──────

  /** Reuse the shared matchesQuery helper for filter matching */
  const matchesFilter = (item: any, filter: Record<string, any>): boolean => {
    return matchesQuery(item, filter);
  };

  /** Apply $pull operations to a document. Supports:
   *  - { $pull: { arrayField: value } } (remove single value)
   *  - { $pull: { arrayField: { $in: [values] } } } (remove multiple values) */
  const applyPull = (item: any, pullOps: Record<string, any>): void => {
    for (const [key, value] of Object.entries(pullOps)) {
      if (!Array.isArray(item[key])) continue;
      if (value && typeof value === 'object' && value.$in && Array.isArray(value.$in)) {
        item[key] = item[key].filter((v: any) => !value.$in.includes(v));
      } else {
        item[key] = item[key].filter((v: any) => v !== value);
      }
    }
  };

  Model.updateMany = async (filter: Record<string, any>, update: Record<string, any>): Promise<{ modifiedCount: number }> => {
    let modified = 0;
    for (const [, item] of collection.entries()) {
      if (matchesFilter(item, filter)) {
        if (update.$pull) applyPull(item, update.$pull);
        if (update.$addToSet) {
          for (const [key, val] of Object.entries(update.$addToSet)) {
            if (!Array.isArray(item[key])) item[key] = [];
            if (!item[key].includes(val)) item[key].push(val);
          }
        }
        // $set / $unset — the operators every bulk "mark as read" style update
        // uses. Without these the call reported a modifiedCount while changing
        // nothing, so mock mode silently lost every bulk write.
        if (update.$set && typeof update.$set === 'object') {
          Object.assign(item, update.$set);
        }
        if (update.$unset && typeof update.$unset === 'object') {
          for (const key of Object.keys(update.$unset)) delete item[key];
        }
        // Apply plain fields (non-operator keys) as direct assignments
        for (const [key, val] of Object.entries(update)) {
          if (!key.startsWith('$')) {
            item[key] = val;
          }
        }
        item.updatedAt = new Date().toISOString();
        modified++;
      }
    }
    return { modifiedCount: modified };
  };

  Model.deleteMany = async (filter: Record<string, any>): Promise<{ deletedCount: number }> => {
    const toDelete: string[] = [];
    for (const [id, item] of collection.entries()) {
      if (matchesFilter(item, filter)) {
        toDelete.push(id);
      }
    }
    for (const id of toDelete) {
      collection.delete(id);
    }
    return { deletedCount: toDelete.length };
  };

  Model.countDocuments = async (filter?: Record<string, any>): Promise<number> => {
    if (!filter || Object.keys(filter).length === 0) {
      return collection.size;
    }
    let count = 0;
    for (const item of collection.values()) {
      if (matchesQuery(item, filter)) count++;
    }
    return count;
  };

  return Model;
}

// ============================================
// DYNAMIC MODEL LOADER
// ============================================

let models: any = null;

export const loadModels = () => {
  if (models) return models;

  if (isMockMode()) {
    // Return mock models that act as constructors
    models = {
      User: createMockModel('users'),
      Company: createMockModel('companies'),
      BusinessProfile: createMockModel('businessProfiles'),
      Product: createMockModel('products'),
      ProductCategory: createMockModel('productCategories'),
      Founder: createMockModel('founders'),
      Employee: createMockModel('employees'),
      ICP: createMockModel('icps'),
      Persona: createMockModel('personas'),
      Competitor: createMockModel('competitors'),
      Brand: createMockModel('brands'),
      BrandAsset: createMockModel('brandAssets'),
      Stationery: createMockModel('stationery'),
      StationeryTemplate: createMockModel('stationeryTemplates'),
      WebsitePage: createMockModel('websitePages'),
      Blog: createMockModel('blogs'),
      BlogContentOS: createMockModel('blogContentOS'),
      NewsletterContentOS: createMockModel('newsletterContentOS'),
      Newsletter: createMockModel('newsletters'),
      LandingPageContentOS: createMockModel('landingPageContentOS'),
      HostingConnection: createMockModel('hostingConnections'),
      LandingPageDeployment: createMockModel('landingPageDeployments'),
      WebsiteDeployment: createMockModel('websiteDeployments'),
      LandingPageLead: createMockModel('landingPageLeads'),
      FAQ: createMockModel('faqs'),
      FAQCategory: createMockModel('faqCategories'),
      Testimonial: createMockModel('testimonials'),
      SalesScript: createMockModel('salesScripts'),
      SalesCollateral: createMockModel('salesCollateral'),
      VideoContent: createMockModel('videoContent'),
      AudioContent: createMockModel('audioContents'),
      WhatsAppCampaign: createMockModel('whatsappCampaigns'),
      AdCampaign: createMockModel('adCampaigns'),
      Ad: createMockModel('ads'),
      AdAudience: createMockModel('adAudiences'),
      AdBudget: createMockModel('adBudgets'),
      AdCreativeAsset: createMockModel('adCreativeAssets'),
      AdABTest: createMockModel('adABTests'),
      AdAIRecommendation: createMockModel('adAIRecommendations'),
      EventCategory: createMockModel('eventCategories'),
      Event: createMockModel('events'),
      EventSession: createMockModel('eventSessions'),
      EventResource: createMockModel('eventResources'),
      // PR Content Engine
      ExpertColumn: createMockModel('expertColumns'),
      ExpertColumnPlan: createMockModel('expertColumnPlans'),
      PressRelease: createMockModel('pressReleases'),
      FounderBio: createMockModel('founderBios'),
      MediaKit: createMockModel('mediaKits'),
      NewsStory: createMockModel('newsStories'),
      ThoughtLeadership: createMockModel('thoughtLeadership'),
      PRHeadlineOption: createMockModel('prHeadlineOptions'),
      PRQuote: createMockModel('prQuotes'),
      MediaOutreach: createMockModel('mediaOutreach'),
      PRCalendarEntry: createMockModel('prCalendarEntries'),
      PRContentRepurpose: createMockModel('prContentRepurposes'),
      PRContentTheme: createMockModel('prContentThemes'),
      // Loyalty Programme
      // Referral
      ReferralOffer: createMockModel('referralOffers'),
      // Awards & Publications
      Award: createMockModel('awards'),
      BookCategory: createMockModel('bookCategories'),
      Book: createMockModel('books'),
      BookChapter: createMockModel('bookChapters'),
      BookSection: createMockModel('bookSections'),
      BookContentBlock: createMockModel('bookContentBlocks'),
      IntroScript: createMockModel('introScripts'),
      SpeakingEngagement: createMockModel('speakingEngagements'),
      CaseStudyCategory: createMockModel('caseStudyCategories'),
      CaseStudy: createMockModel('caseStudies'),
      EmailTemplateCategory: createMockModel('emailTemplateCategories'),
      EmailTemplate: createMockModel('emailTemplates'),
      AiContext: createMockModel('aiContexts'),
      AiGeneratedVersion: createMockModel('aiGeneratedVersions'),
      ModuleData: createMockModel('moduleData'),
      ChatSession: createMockModel('chatSessions'),
      // Subscription & Billing
      SubscriptionPackage: createMockModel('subscriptionPackages'),
      CompanySubscription: createMockModel('companySubscriptions'),
      PaymentGatewayConfig: createMockModel('paymentGatewayConfigs'),
      SmtpConfig: createMockModel('smtpConfigs'),
      CurrencyConfig: createMockModel('currencyConfigs'),
      Invoice: createMockModel('invoices'),
      SubscriptionAuditLog: createMockModel('subscriptionAuditLogs'),
      // Dynamic Pricing Engine
      PricingCategory: createMockModel('pricingCategories'),
      PricingItem: createMockModel('pricingItems'),
      PricingRule: createMockModel('pricingRules'),
      PricingDiscount: createMockModel('pricingDiscounts'),
      PricingTax: createMockModel('pricingTaxes'),
      PricingAddon: createMockModel('pricingAddons'),
      // Google Business Profile (GMB)
      GmbLocation: createMockModel('gmblocations'),
      GmbPost: createMockModel('gmbposts'),
      GmbReview: createMockModel('gmbreviews'),
      GmbMedia: createMockModel('gmbmedia'),
      GmbInsight: createMockModel('gmbinsights'),
      GmbAiContent: createMockModel('gmbaicontents'),
      GmbReport: createMockModel('gmbreports'),
      GoogleDriveToken: createMockModel('googleDriveTokens'),
      // n8n workflow automation
      N8nConfig: createMockModel('n8nConfigs'),
      // Zapier automation
      ZapierConfig: createMockModel('zapierConfigs'),
      // YouTube (Social Media OS connectivity)
      YouTubeAccount: createMockModel('youtubeAccounts'),
      YouTubeAppConfig: createMockModel('youtubeAppConfigs'),
      SocialMediaPublication: createMockModel('socialMediaPublications'),
      AiKeyHealthLog: createMockModel('aiKeyHealthLogs'),
      // Facebook (Social Media OS connectivity)
      FacebookAccount: createMockModel('facebookAccounts'),
      FacebookAppConfig: createMockModel('facebookAppConfigs'),
      // Facebook N8n (Social Media OS — n8n-based publishing)
      FacebookN8nConfig: createMockModel('facebookN8nConfigs'),
      // Instagram N8n (Social Media OS — n8n-based publishing)
      InstagramN8nConfig: createMockModel('instagramN8nConfigs'),
      // Threads N8n (Social Media OS — n8n-based publishing)
      ThreadsN8nConfig: createMockModel('threadsN8nConfigs'),
      // Instagram (Social Media OS connectivity)
      InstagramAccount: createMockModel('instagramAccounts'),
      // LinkedIn (Social Media OS connectivity)
      LinkedInAccount: createMockModel('linkedinAccounts'),
      LinkedInAppConfig: createMockModel('linkedinAppConfigs'),
      // X (Twitter) (Social Media OS connectivity)
      TwitterAccount: createMockModel('twitterAccounts'),
      TwitterAppConfig: createMockModel('twitterAppConfigs'),
      // Threads (Meta Threads) (Social Media OS connectivity)
      ThreadsAccount: createMockModel('threadsAccounts'),
      ThreadsAppConfig: createMockModel('threadsAppConfigs'),
      // Pinterest (Social Media OS connectivity)
      PinterestAccount: createMockModel('pinterestAccounts'),
      PinterestAppConfig: createMockModel('pinterestAppConfigs'),
      // Google Ads (Super Admin → Settings)
      GoogleAdsAppConfig: createMockModel('googleAdsAppConfigs'),
      // Google Business Profile (Super Admin → Settings)
      GoogleBusinessProfileConfig: createMockModel('googleBusinessProfileConfigs'),
      // Meta Ads (Super Admin → Settings)
      MetaAdsAppConfig: createMockModel('metaAdsAppConfigs'),
      // WhatsApp Business API (Super Admin → Settings)
      WhatsAppAppConfig: createMockModel('whatsappAppConfigs'),
      // WhatsApp Business API (per-tenant WABA connections)
      WhatsAppConnection: createMockModel('whatsappConnections'),
      // WordPress (Super Admin → Settings)
      WordPressConfig: createMockModel('wordpressConfigs'),
      // Blogger (Google/Blogger integration)
      BloggerAppConfig: createMockModel('bloggerAppConfigs'),
      BloggerAccount: createMockModel('bloggerAccounts'),
      // Blog Generation
      BlogGeneration: createMockModel('blogGenerations'),
      // Social Media Campaign V2
      SocialMediaCampaign: createMockModel('socialMediaCampaigns'),
      // Guerrilla Campaign
      GuerrillaCampaign: createMockModel('guerrillaCampaigns'),
      // Image Generation
      ImageGeneration: createMockModel('imageGenerations'),
      // Wikipedia & Knowledge Panel
      WikipediaArticle: createMockModel('wikipediaArticles'),
      KnowledgePanel: createMockModel('knowledgePanels'),
      // Interview & Media Prep
      InterviewMediaPrep: createMockModel('interviewMediaPrep'),
      // Speaking Engagement Memory (anti-repetition)
      SpeakingEngagementMemory: createMockModel('speakingEngagementMemories'),
      // Magazine & Sponsorship
      // Marketing Calendar & Timing
      MarketingCalendarEvent: createMockModel('marketingCalendarEvents'),
      SeasonalPlan: createMockModel('seasonalPlans'),
      // Marketing Channels Map
      MarketingChannel: createMockModel('marketingChannels'),
      ChannelMap: createMockModel('channelMaps'),
      // GEO Optimization
      GEOOptimization: createMockModel('geoOptimizations'),
      // GEO Intelligence
      GeoAuditSnapshot: createMockModel('geoAuditSnapshots'),
      GeoPlatformMetric: createMockModel('geoPlatformMetrics'),
      GeoCitationOpportunity: createMockModel('geoCitationOpportunities'),
      GeoRecommendation: createMockModel('geoRecommendations'),
      GeoSimulationRun: createMockModel('geoSimulationRuns'),
      GeoAuditSettings: createMockModel('geoAuditSettings'),
      // Funding Module
      PitchDeck: createMockModel('pitchDecks'),
      FinancialModel: createMockModel('financialModels'),
      Investor: createMockModel('investors'),
      FundingRound: createMockModel('fundingRounds'),
      CapTable: createMockModel('capTables'),
      // MOAT Analysis
      MoatAnalysis: createMockModel('moatAnalyses'),
      // SWOT Analysis
      SwotAnalysis: createMockModel('swotAnalyses'),
      // Prompt Config
      PromptConfig: createMockModel('promptconfigs'),
      // Workflow Templates
      WorkflowTemplate: createMockModel('workflowtemplates'),
      // RBAC
      Role: createMockModel('roles'),
      UserAccessOverride: createMockModel('useraccessoverrides'),
      AuditLog: createMockModel('auditlogs'),
      ActivityLog: createMockModel('activitylogs'),
      Notification: createMockModel('notifications'),
      NotificationPreference: createMockModel('notificationPreferences'),
      // Sales Performance
      CommissionPlan: createMockModel('commissionPlans'),
      Commission: createMockModel('commissions'),
      CommissionPayout: createMockModel('commissionPayouts'),
      SalesQuota: createMockModel('salesQuotas'),
      TeamQuota: createMockModel('teamQuotas'),
      SalesDashboard: createMockModel('salesDashboards'),
      Proposal: createMockModel('proposals'),
      FeatureRequest: createMockModel('featureRequests'),
      FeatureRequestComment: createMockModel('featureRequestComments'),
      FeatureRequestNotificationLog: createMockModel('featureRequestNotificationLogs'),
      SupportTicket: createMockModel('supportTickets'),
      SupportTeam: createMockModel('supportTeams'),
      Coupon: createMockModel('coupons'),
      TemplateStyle: createMockModel('templateStyles'),
      // Executive CV
      ExecutiveCV: createMockModel('executiveCvs'),
      // Wikipedia Profile
      WikipediaProfile: createMockModel('wikipediaProfiles'),
      // Email Signature
      EmailSignature: createMockModel('emailSignatures'),
      // Signature Templates (Super Admin signature design library)
      SignatureTemplate: createMockModel('signatureTemplates'),
      // Newsletter Templates (Super Admin newsletter design library)
      NewsletterTemplate: createMockModel('newsletterTemplates'),
      // Email Integration (Brevo)
      EmailIntegration: createMockModel('emailIntegrations'),
      EmailCampaign: createMockModel('emailCampaigns'),
      EmailContact: createMockModel('emailContacts'),
      // Automation Workflows
      AutomationWorkflow: createMockModel('automationWorkflows'),
      AutomationInstance: createMockModel('automationInstances'),
      AutomationLog: createMockModel('automationLogs'),
      // Email Designer Templates
      EmailDesignerTemplate: createMockModel('emailDesignerTemplates'),
      // API Token Management
      ApiToken: createMockModel('apiTokens'),
      // Library (central icon repository — super-admin managed)
      LibraryIcon: createMockModel('libraryIcons'),
      // Backup & Restore
      Backup: createMockModel('backups'),
      BackupSettings: createMockModel('backupSettings'),
      BrandingSettings: createMockModel('brandingSettings'),
      RestoreLog: createMockModel('restoreLogs'),
      BackupNotificationLog: createMockModel('backupNotificationLogs'),
      // Two-Factor Authentication
      UserTwoFactor: createMockModel('userTwoFactors'),
      TrustedDevice: createMockModel('trustedDevices'),
      TwoFactorChallenge: createMockModel('twoFactorChallenges'),
      TwoFactorPolicy: createMockModel('twoFactorPolicies'),
      // Reputation & Reviews
      Complaint: createMockModel('complaints'),
      ReputationReview: createMockModel('reputationReviews'),
      MediaMention: createMockModel('mediaMentions'),
      // Email Dispatch
      EmailDispatch: createMockModel('emailDispatches'),
      // BrandKit
      BrandKit: createMockModel('brandKits'),
      BrandKitTemplate: createMockModel('brandKitTemplates'),
      BrandKitAsset: createMockModel('brandKitAssets'),
      BrandKitOrder: createMockModel('brandKitOrders'),
    };
  } else {
    // Import and return real models
    const { User: RealUser } = require('./User');
    const { Company: RealCompany } = require('./Company');
    const { BusinessProfile: RealBusinessProfile } = require('./BusinessProfile');
    const { Product: RealProduct, ProductCategory: RealProductCategory } = require('./Product');
    const { Founder: RealFounder } = require('./Founder');
    const { Employee: RealEmployee } = require('./Employee');
    const { ICP: RealICP } = require('./ICP');
    const { Persona: RealPersona } = require('./Persona');
    const { Competitor: RealCompetitor } = require('./Competitor');
    const { Brand: RealBrand } = require('./Brand');
    const { BrandAsset: RealBrandAsset } = require('./BrandAsset');
    const { Stationery: RealStationery } = require('./Stationery');
    const { StationeryTemplate: RealStationeryTemplate } = require('./StationeryTemplate');
    const { WebsitePage: RealWebsitePage } = require('./WebsitePage');
    const { Blog: RealBlog } = require('./Blog');
    const { BlogContentOS: RealBlogContentOS } = require('./BlogContentOS');
    const { NewsletterContentOS: RealNewsletterContentOS } = require('./NewsletterContentOS');
    const { Newsletter: RealNewsletter } = require('./Newsletter');
    const { LandingPageContentOS: RealLandingPageContentOS } = require('./LandingPageContentOS');
    const { HostingConnection: RealHostingConnection } = require('./HostingConnection');
    const { LandingPageDeployment: RealLandingPageDeployment } = require('./LandingPageDeployment');
    const { WebsiteDeployment: RealWebsiteDeployment } = require('./WebsiteDeployment');
    const { LandingPageLead: RealLandingPageLead } = require('./LandingPageLead');
    const { FAQ: RealFAQ, FAQCategory: RealFAQCategory } = require('./FAQ');
    const { Testimonial: RealTestimonial } = require('./Testimonial');
    const { SalesScript: RealSalesScript } = require('./SalesScript');
    const { SalesCollateral: RealSalesCollateral } = require('./SalesCollateral');
    const { VideoContent: RealVideoContent } = require('./VideoContent');
    const { AudioContent: RealAudioContent } = require('./AudioContent');
    const { WhatsAppCampaign: RealWhatsAppCampaign } = require('./WhatsAppCampaign');
    const { AdCampaign: RealAdCampaign } = require('./AdCampaign');
    const { Ad: RealAd } = require('./Ad');
    const { AdAudience: RealAdAudience } = require('./AdAudience');
    const { AdBudget: RealAdBudget } = require('./AdBudget');
    const { AdCreativeAsset: RealAdCreativeAsset } = require('./AdCreativeAsset');
    const { AdABTest: RealAdABTest } = require('./AdABTest');
    const { AdAIRecommendation: RealAdAIRecommendation } = require('./AdAIRecommendation');
    const { EventCategory: RealEventCategory, Event: RealEvent, EventSession: RealEventSession, EventResource: RealEventResource } = require('./Event');
    const { ExpertColumn: RealExpertColumn } = require('./ExpertColumn');
    const { ExpertColumnPlan: RealExpertColumnPlan } = require('./ExpertColumnPlan');
    const { PressRelease: RealPressRelease } = require('./PressRelease');
    const { FounderBio: RealFounderBio } = require('./FounderBio');
    const { MediaKit: RealMediaKit } = require('./MediaKit');
    const { NewsStory: RealNewsStory } = require('./NewsStory');
    const { ThoughtLeadership: RealThoughtLeadership } = require('./ThoughtLeadership');
    const { PRHeadlineOption: RealPRHeadlineOption } = require('./PRHeadlineOption');
    const { PRQuote: RealPRQuote } = require('./PRQuote');
    const { MediaOutreach: RealMediaOutreach } = require('./MediaOutreach');
    const { PRCalendarEntry: RealPRCalendarEntry } = require('./PRCalendarEntry');
    const { PRContentRepurpose: RealPRContentRepurpose } = require('./PRContentRepurpose');
    const { PRContentTheme: RealPRContentTheme } = require('./PRContentTheme');
    const { ReferralOffer: RealReferralOffer } = require('./Referral');
    const { Award: RealAward } = require('./Award');
    const { BookCategory: RealBookCategory, Book: RealBook, BookChapter: RealBookChapter, BookSection: RealBookSection, BookContentBlock: RealBookContentBlock } = require('./Book');
    const { IntroScript: RealIntroScript } = require('./IntroScript');
    const { SpeakingEngagement: RealSpeakingEngagement } = require('./SpeakingEngagement');
    const { CaseStudyCategory: RealCaseStudyCategory, CaseStudy: RealCaseStudy } = require('./CaseStudy');
    const { EmailTemplateCategory: RealEmailTemplateCategory, EmailTemplate: RealEmailTemplate } = require('./EmailTemplate');
    const { AiContext: RealAiContext } = require('./AiContext');
    const { AiGeneratedVersion: RealAiGeneratedVersion } = require('./AiGeneratedVersion');
    const { ModuleData: RealModuleData } = require('./ModuleData');
    const { ChatSession: RealChatSession } = require('./ChatSession');
    // Subscription & Billing
    const { SubscriptionPackage: RealSubscriptionPackage } = require('./SubscriptionPackage');
    const { CompanySubscription: RealCompanySubscription } = require('./CompanySubscription');
    const { PaymentGatewayConfig: RealPaymentGatewayConfig } = require('./PaymentGatewayConfig');
    const { SmtpConfig: RealSmtpConfig } = require('./SmtpConfig');
    const { CurrencyConfig: RealCurrencyConfig } = require('./CurrencyConfig');
    const { Invoice: RealInvoice } = require('./Invoice');
    const { SubscriptionAuditLog: RealSubscriptionAuditLog } = require('./SubscriptionAuditLog');
    // Dynamic Pricing Engine
    const { PricingCategory: RealPricingCategory } = require('./PricingCategory');
    const { PricingItem: RealPricingItem } = require('./PricingItem');
    const { PricingRule: RealPricingRule } = require('./PricingRule');
    const { PricingDiscount: RealPricingDiscount } = require('./PricingDiscount');
    const { PricingTax: RealPricingTax } = require('./PricingTax');
    const { PricingAddon: RealPricingAddon } = require('./PricingAddon');
    // Google Business Profile (GMB)
    const { GmbLocation: RealGmbLocation } = require('./GmbLocation');
    const { GmbPost: RealGmbPost } = require('./GmbPost');
    const { GmbReview: RealGmbReview } = require('./GmbReview');
    const { GmbMedia: RealGmbMedia } = require('./GmbMedia');
    const { GmbInsight: RealGmbInsight } = require('./GmbInsight');
    const { GmbAiContent: RealGmbAiContent } = require('./GmbAiContent');
    const { GmbReport: RealGmbReport } = require('./GmbReport');
    const { GoogleDriveToken: RealGoogleDriveToken } = require('./GoogleDriveToken');
    // n8n workflow automation
    const { N8nConfig: RealN8nConfig } = require('./N8nConfig');
    const { ZapierConfig: RealZapierConfig } = require('./ZapierConfig');
    // YouTube (Social Media OS connectivity)
    const { YouTubeAccount: RealYouTubeAccount } = require('./YouTubeAccount');
    const { YouTubeAppConfig: RealYouTubeAppConfig } = require('./YouTubeAppConfig');
    const { SocialMediaPublication: RealSocialMediaPublication } = require('./SocialMediaPublication');
    const { AiKeyHealthLog: RealAiKeyHealthLog } = require('./AiKeyHealthLog');
    // Facebook (Social Media OS connectivity)
    const { FacebookAccount: RealFacebookAccount } = require('./FacebookAccount');
    const { FacebookAppConfig: RealFacebookAppConfig } = require('./FacebookAppConfig');
    // Facebook N8n (Social Media OS — n8n-based publishing)
    const { FacebookN8nConfig: RealFacebookN8nConfig } = require('./FacebookN8nConfig');
    // Instagram N8n (Social Media OS — n8n-based publishing)
    const { InstagramN8nConfig: RealInstagramN8nConfig } = require('./InstagramN8nConfig');
    // Threads N8n (Social Media OS — n8n-based publishing)
    const { ThreadsN8nConfig: RealThreadsN8nConfig } = require('./ThreadsN8nConfig');
    // Instagram (Social Media OS connectivity)
    const { InstagramAccount: RealInstagramAccount } = require('./InstagramAccount');
    // LinkedIn (Social Media OS connectivity)
    const { LinkedInAccount: RealLinkedInAccount } = require('./LinkedInAccount');
    const { LinkedInAppConfig: RealLinkedInAppConfig } = require('./LinkedInAppConfig');
    // X (Twitter) (Social Media OS connectivity)
    const { TwitterAccount: RealTwitterAccount } = require('./TwitterAccount');
    const { TwitterAppConfig: RealTwitterAppConfig } = require('./TwitterAppConfig');
    // Threads (Meta Threads) (Social Media OS connectivity)
    const { ThreadsAccount: RealThreadsAccount } = require('./ThreadsAccount');
    const { ThreadsAppConfig: RealThreadsAppConfig } = require('./ThreadsAppConfig');
    // Pinterest (Social Media OS connectivity)
    const { PinterestAccount: RealPinterestAccount } = require('./PinterestAccount');
    const { PinterestAppConfig: RealPinterestAppConfig } = require('./PinterestAppConfig');
    // Google Ads (Super Admin → Settings)
    const { GoogleAdsAppConfig: RealGoogleAdsAppConfig } = require('./GoogleAdsAppConfig');
    // Google Business Profile (Super Admin → Settings)
    const { GoogleBusinessProfileConfig: RealGoogleBusinessProfileConfig } = require('./GoogleBusinessProfileConfig');
    // Meta Ads (Super Admin → Settings)
    const { MetaAdsAppConfig: RealMetaAdsAppConfig } = require('./MetaAdsAppConfig');
    // WhatsApp Business API (Super Admin → Settings)
    const { WhatsAppAppConfig: RealWhatsAppAppConfig } = require('./WhatsAppAppConfig');
    // WhatsApp Business API (per-tenant WABA connections)
    const { WhatsAppConnection: RealWhatsAppConnection } = require('./WhatsAppConnection');
    // WordPress (Super Admin → Settings)
    const { WordPressConfig: RealWordPressConfig } = require('./WordPressConfig');
    // Blogger (Google/Blogger integration)
    const { BloggerAppConfig: RealBloggerAppConfig } = require('./BloggerAppConfig');
    const { BloggerAccount: RealBloggerAccount } = require('./BloggerAccount');
    // Blog Generation
    const { BlogGeneration: RealBlogGeneration } = require('./BlogGeneration');
    const { SocialMediaCampaign: RealSocialMediaCampaign } = require('./SocialMediaCampaign');
    // Guerrilla Campaign
    const { GuerrillaCampaign: RealGuerrillaCampaign } = require('./GuerrillaCampaign');
    // Image Generation
    const { ImageGeneration: RealImageGeneration } = require('./ImageGeneration');
    // Wikipedia & Knowledge Panel
    const { WikipediaArticle: RealWikipediaArticle } = require('./WikipediaArticle');
    const { KnowledgePanel: RealKnowledgePanel } = require('./KnowledgePanel');
    // Interview & Media Prep
    const { InterviewMediaPrep: RealInterviewMediaPrep } = require('./InterviewMediaPrep');
    // Speaking Engagement Memory (anti-repetition)
    const { SpeakingEngagementMemory: RealSpeakingEngagementMemory } = require('./SpeakingEngagementMemory');
    // Magazine & Sponsorship
    // Marketing Calendar & Timing
    const { MarketingCalendarEvent: RealMarketingCalendarEvent, SeasonalPlan: RealSeasonalPlan } = require('./MarketingCalendar');
    // Marketing Channels Map
    const { MarketingChannel: RealMarketingChannel, ChannelMap: RealChannelMap } = require('./MarketingChannel');
    // GEO Optimization
    const { GEOOptimization: RealGEOOptimization } = require('./GEOOptimization');
    // GEO Intelligence
    const {
      GeoAuditSnapshot: RealGeoAuditSnapshot,
      GeoPlatformMetric: RealGeoPlatformMetric,
      GeoCitationOpportunity: RealGeoCitationOpportunity,
      GeoRecommendation: RealGeoRecommendation,
      GeoSimulationRun: RealGeoSimulationRun,
      GeoAuditSettings: RealGeoAuditSettings,
    } = require('./GeoIntelligence');
    // Funding Module
    const { PitchDeck: RealPitchDeck } = require('./PitchDeck');
    const { FinancialModel: RealFinancialModel } = require('./FinancialModel');
    const { Investor: RealInvestor } = require('./Investor');
    const { FundingRound: RealFundingRound } = require('./FundingRound');
    const { CapTable: RealCapTable } = require('./CapTable');
    // MOAT Analysis
    const { MoatAnalysis: RealMoatAnalysis } = require('./MoatAnalysis');
    // SWOT Analysis
    const { SwotAnalysis: RealSwotAnalysis } = require('./SwotAnalysis');
    const { Presentation: RealPresentation } = require('./Presentation');
    // Prompt Config
    const { PromptConfig: RealPromptConfig } = require('./PromptConfig');
    const { WorkflowTemplate: RealWorkflowTemplate } = require('./WorkflowTemplate');
    // RBAC
    const { Role: RealRole } = require('./Role');
    const { UserAccessOverride: RealUserAccessOverride } = require('./UserAccessOverride');
    const { AuditLog: RealAuditLog } = require('./AuditLog');
    const { ActivityLog: RealActivityLog } = require('./ActivityLog');
    const { Notification: RealNotification } = require('./Notification');
    const { NotificationPreference: RealNotificationPreference } = require('./NotificationPreference');
    // Sales Performance
    const { CommissionPlan: RealCommissionPlan } = require('./CommissionPlan');
    const { Commission: RealCommission } = require('./Commission');
    const { CommissionPayout: RealCommissionPayout } = require('./CommissionPayout');
    const { SalesQuota: RealSalesQuota } = require('./SalesQuota');
    const { TeamQuota: RealTeamQuota } = require('./TeamQuota');
    const { SalesDashboard: RealSalesDashboard } = require('./SalesDashboard');
    const { Proposal: RealProposal } = require('./Proposal');
    const { FeatureRequest: RealFeatureRequest } = require('./FeatureRequest');
    const { FeatureRequestComment: RealFeatureRequestComment } = require('./FeatureRequestComment');
    const { FeatureRequestNotificationLog: RealFeatureRequestNotificationLog } = require('./FeatureRequestNotificationLog');
    const { SupportTicket: RealSupportTicket } = require('./SupportTicket');
    const { SupportTeam: RealSupportTeam } = require('./SupportTeam');
    const { Coupon: RealCoupon } = require('./Coupon');
    const { TemplateStyle: RealTemplateStyle } = require('./TemplateStyle');
    // Executive CV
    const { ExecutiveCV: RealExecutiveCV } = require('./ExecutiveCV');
    // Wikipedia Profile
    const { WikipediaProfile: RealWikipediaProfile } = require('./WikipediaProfile');
    // Email Signature
    const { EmailSignature: RealEmailSignature } = require('./EmailSignature');
    // Signature Templates (Super Admin signature design library)
    const { SignatureTemplate: RealSignatureTemplate } = require('./SignatureTemplate');
    // Newsletter Templates (Super Admin newsletter design library)
    const { NewsletterTemplate: RealNewsletterTemplate } = require('./NewsletterTemplate');
    // Email Integration (Brevo)
    const { EmailIntegration: RealEmailIntegration } = require('./EmailIntegration');
    const { EmailCampaign: RealEmailCampaign } = require('./EmailCampaign');
    const { EmailContact: RealEmailContact } = require('./EmailContact');
    // Automation Workflows
    const { AutomationWorkflow: RealAutomationWorkflow, AutomationInstance: RealAutomationInstance, AutomationLog: RealAutomationLog } = require('./AutomationWorkflow');
    // Email Designer Templates
    const { EmailDesignerTemplate: RealEmailDesignerTemplate } = require('./EmailDesignerTemplate');
    // API Token Management
    const { ApiToken: RealApiToken } = require('./ApiToken');
    // Library (central icon repository)
    const { LibraryIcon: RealLibraryIcon } = require('./LibraryIcon');
    // Backup & Restore
    const { Backup: RealBackup } = require('./Backup');
    const { BackupSettings: RealBackupSettings } = require('./BackupSettings');
    const { BrandingSettings: RealBrandingSettings } = require('./BrandingSettings');
    const { RestoreLog: RealRestoreLog } = require('./RestoreLog');
    const { BackupNotificationLog: RealBackupNotificationLog } = require('./BackupNotificationLog');
    // Two-Factor Authentication
    const { UserTwoFactor: RealUserTwoFactor } = require('./UserTwoFactor');
    const { TrustedDevice: RealTrustedDevice } = require('./TrustedDevice');
    const { TwoFactorChallenge: RealTwoFactorChallenge } = require('./TwoFactorChallenge');
    const { TwoFactorPolicy: RealTwoFactorPolicy } = require('./TwoFactorPolicy');
    // Reputation & Reviews
    const { Complaint: RealComplaint } = require('./Complaint');
    const { ReputationReview: RealReputationReview } = require('./ReputationReview');
    const { MediaMention: RealMediaMention } = require('./MediaMention');
    // Email Dispatch
    const { EmailDispatch: RealEmailDispatch } = require('./EmailDispatch');
    // BrandKit
    const { BrandKit: RealBrandKit } = require('./BrandKit');
    const { BrandKitTemplate: RealBrandKitTemplate } = require('./BrandKitTemplate');
    const { BrandKitAsset: RealBrandKitAsset } = require('./BrandKitAsset');
    const { BrandKitOrder: RealBrandKitOrder } = require('./BrandKitOrder');

    models = {
      User: RealUser,
      Company: RealCompany,
      BusinessProfile: RealBusinessProfile,
      Product: RealProduct,
      ProductCategory: RealProductCategory,
      Founder: RealFounder,
      Employee: RealEmployee,
      ICP: RealICP,
      Persona: RealPersona,
      Competitor: RealCompetitor,
      Brand: RealBrand,
      BrandAsset: RealBrandAsset,
      Stationery: RealStationery,
      StationeryTemplate: RealStationeryTemplate,
      WebsitePage: RealWebsitePage,
      Blog: RealBlog,
      BlogContentOS: RealBlogContentOS,
      NewsletterContentOS: RealNewsletterContentOS,
      Newsletter: RealNewsletter,
      LandingPageContentOS: RealLandingPageContentOS,
      HostingConnection: RealHostingConnection,
      LandingPageDeployment: RealLandingPageDeployment,
      WebsiteDeployment: RealWebsiteDeployment,
      LandingPageLead: RealLandingPageLead,
      FAQ: RealFAQ,
      FAQCategory: RealFAQCategory,
      Testimonial: RealTestimonial,
      SalesScript: RealSalesScript,
      SalesCollateral: RealSalesCollateral,
      VideoContent: RealVideoContent,
      AudioContent: RealAudioContent,
      WhatsAppCampaign: RealWhatsAppCampaign,
      AdCampaign: RealAdCampaign,
      Ad: RealAd,
      AdAudience: RealAdAudience,
      AdBudget: RealAdBudget,
      AdCreativeAsset: RealAdCreativeAsset,
      AdABTest: RealAdABTest,
      AdAIRecommendation: RealAdAIRecommendation,
      EventCategory: RealEventCategory,
      Event: RealEvent,
      EventSession: RealEventSession,
      EventResource: RealEventResource,
      // PR Content Engine
      ExpertColumn: RealExpertColumn,
      ExpertColumnPlan: RealExpertColumnPlan,
      PressRelease: RealPressRelease,
      FounderBio: RealFounderBio,
      MediaKit: RealMediaKit,
      NewsStory: RealNewsStory,
      ThoughtLeadership: RealThoughtLeadership,
      PRHeadlineOption: RealPRHeadlineOption,
      PRQuote: RealPRQuote,
      MediaOutreach: RealMediaOutreach,
      PRCalendarEntry: RealPRCalendarEntry,
      PRContentRepurpose: RealPRContentRepurpose,
      PRContentTheme: RealPRContentTheme,
      // Loyalty Programme
      // Referral
      ReferralOffer: RealReferralOffer,
      // Awards & Publications
      Award: RealAward,
      BookCategory: RealBookCategory,
      Book: RealBook,
      BookChapter: RealBookChapter,
      BookSection: RealBookSection,
      BookContentBlock: RealBookContentBlock,
      IntroScript: RealIntroScript,
      SpeakingEngagement: RealSpeakingEngagement,
      CaseStudyCategory: RealCaseStudyCategory,
      CaseStudy: RealCaseStudy,
      EmailTemplateCategory: RealEmailTemplateCategory,
      EmailTemplate: RealEmailTemplate,
      AiContext: RealAiContext,
      AiGeneratedVersion: RealAiGeneratedVersion,
      ModuleData: RealModuleData,
      ChatSession: RealChatSession,
      // Subscription & Billing
      SubscriptionPackage: RealSubscriptionPackage,
      CompanySubscription: RealCompanySubscription,
      PaymentGatewayConfig: RealPaymentGatewayConfig,
      SmtpConfig: RealSmtpConfig,
      CurrencyConfig: RealCurrencyConfig,
      Invoice: RealInvoice,
      SubscriptionAuditLog: RealSubscriptionAuditLog,
      // Dynamic Pricing Engine
      PricingCategory: RealPricingCategory,
      PricingItem: RealPricingItem,
      PricingRule: RealPricingRule,
      PricingDiscount: RealPricingDiscount,
      PricingTax: RealPricingTax,
      PricingAddon: RealPricingAddon,
      // Google Business Profile (GMB)
      GmbLocation: RealGmbLocation,
      GmbPost: RealGmbPost,
      GmbReview: RealGmbReview,
      GmbMedia: RealGmbMedia,
      GmbInsight: RealGmbInsight,
      GmbAiContent: RealGmbAiContent,
      GmbReport: RealGmbReport,
      GoogleDriveToken: RealGoogleDriveToken,
      // n8n workflow automation
      N8nConfig: RealN8nConfig,
      ZapierConfig: RealZapierConfig,
      // YouTube (Social Media OS connectivity)
      YouTubeAccount: RealYouTubeAccount,
      YouTubeAppConfig: RealYouTubeAppConfig,
      SocialMediaPublication: RealSocialMediaPublication,
      AiKeyHealthLog: RealAiKeyHealthLog,
      // Facebook (Social Media OS connectivity)
      FacebookAccount: RealFacebookAccount,
      FacebookAppConfig: RealFacebookAppConfig,
      // Facebook N8n (Social Media OS — n8n-based publishing)
      FacebookN8nConfig: RealFacebookN8nConfig,
      // Instagram N8n (Social Media OS — n8n-based publishing)
      InstagramN8nConfig: RealInstagramN8nConfig,
      // Threads N8n (Social Media OS — n8n-based publishing)
      ThreadsN8nConfig: RealThreadsN8nConfig,
      // Instagram (Social Media OS connectivity)
      InstagramAccount: RealInstagramAccount,
      // LinkedIn (Social Media OS connectivity)
      LinkedInAccount: RealLinkedInAccount,
      LinkedInAppConfig: RealLinkedInAppConfig,
      // X (Twitter) (Social Media OS connectivity)
      TwitterAccount: RealTwitterAccount,
      TwitterAppConfig: RealTwitterAppConfig,
      // Threads (Meta Threads) (Social Media OS connectivity)
      ThreadsAccount: RealThreadsAccount,
      ThreadsAppConfig: RealThreadsAppConfig,
      // Pinterest (Social Media OS connectivity)
      PinterestAccount: RealPinterestAccount,
      PinterestAppConfig: RealPinterestAppConfig,
      // Google Ads (Super Admin → Settings)
      GoogleAdsAppConfig: RealGoogleAdsAppConfig,
      // Google Business Profile (Super Admin → Settings)
      GoogleBusinessProfileConfig: RealGoogleBusinessProfileConfig,
      // Meta Ads (Super Admin → Settings)
      MetaAdsAppConfig: RealMetaAdsAppConfig,
      // WhatsApp Business API (Super Admin → Settings)
      WhatsAppAppConfig: RealWhatsAppAppConfig,
      // WhatsApp Business API (per-tenant WABA connections)
      WhatsAppConnection: RealWhatsAppConnection,
      // WordPress (Super Admin → Settings)
      WordPressConfig: RealWordPressConfig,
      // Blogger (Google/Blogger integration)
      BloggerAppConfig: RealBloggerAppConfig,
      BloggerAccount: RealBloggerAccount,
      // Blog Generation
      BlogGeneration: RealBlogGeneration,
      // Social Media Campaign V2
      SocialMediaCampaign: RealSocialMediaCampaign,
      // Guerrilla Campaign
      GuerrillaCampaign: RealGuerrillaCampaign,
      // Image Generation
      ImageGeneration: RealImageGeneration,
      // Wikipedia & Knowledge Panel
      WikipediaArticle: RealWikipediaArticle,
      KnowledgePanel: RealKnowledgePanel,
      // Interview & Media Prep
      InterviewMediaPrep: RealInterviewMediaPrep,
      // Speaking Engagement Memory (anti-repetition)
      SpeakingEngagementMemory: RealSpeakingEngagementMemory,
      // Magazine & Sponsorship
      // Marketing Calendar & Timing
      MarketingCalendarEvent: RealMarketingCalendarEvent,
      SeasonalPlan: RealSeasonalPlan,
      // Marketing Channels Map
      MarketingChannel: RealMarketingChannel,
      ChannelMap: RealChannelMap,
      // GEO Optimization
      GEOOptimization: RealGEOOptimization,
      // GEO Intelligence
      GeoAuditSnapshot: RealGeoAuditSnapshot,
      GeoPlatformMetric: RealGeoPlatformMetric,
      GeoCitationOpportunity: RealGeoCitationOpportunity,
      GeoRecommendation: RealGeoRecommendation,
      GeoSimulationRun: RealGeoSimulationRun,
      GeoAuditSettings: RealGeoAuditSettings,
      // Funding Module
      PitchDeck: RealPitchDeck,
      FinancialModel: RealFinancialModel,
      Investor: RealInvestor,
      FundingRound: RealFundingRound,
      CapTable: RealCapTable,
      // MOAT Analysis
      MoatAnalysis: RealMoatAnalysis,
      // SWOT Analysis
      SwotAnalysis: RealSwotAnalysis,
      Presentation: RealPresentation,
      // Prompt Config
      PromptConfig: RealPromptConfig,
      // Workflow Templates
      WorkflowTemplate: RealWorkflowTemplate,
      // RBAC
      Role: RealRole,
      UserAccessOverride: RealUserAccessOverride,
      AuditLog: RealAuditLog,
      ActivityLog: RealActivityLog,
      Notification: RealNotification,
      NotificationPreference: RealNotificationPreference,
      // Sales Performance
      CommissionPlan: RealCommissionPlan,
      Commission: RealCommission,
      CommissionPayout: RealCommissionPayout,
      SalesQuota: RealSalesQuota,
      TeamQuota: RealTeamQuota,
      SalesDashboard: RealSalesDashboard,
      Proposal: RealProposal,
      FeatureRequest: RealFeatureRequest,
      FeatureRequestComment: RealFeatureRequestComment,
      FeatureRequestNotificationLog: RealFeatureRequestNotificationLog,
      SupportTicket: RealSupportTicket,
      SupportTeam: RealSupportTeam,
      Coupon: RealCoupon,
      TemplateStyle: RealTemplateStyle,
      // Executive CV
      ExecutiveCV: RealExecutiveCV,
      // Wikipedia Profile
      WikipediaProfile: RealWikipediaProfile,
      // Email Signature
      EmailSignature: RealEmailSignature,
      // Signature Templates (Super Admin signature design library)
      SignatureTemplate: RealSignatureTemplate,
      // Newsletter Templates (Super Admin newsletter design library)
      NewsletterTemplate: RealNewsletterTemplate,
      // Email Integration (Brevo)
      EmailIntegration: RealEmailIntegration,
      EmailCampaign: RealEmailCampaign,
      EmailContact: RealEmailContact,
      // Automation Workflows
      AutomationWorkflow: RealAutomationWorkflow,
      AutomationInstance: RealAutomationInstance,
      AutomationLog: RealAutomationLog,
      // Email Designer Templates
      EmailDesignerTemplate: RealEmailDesignerTemplate,
      // API Token Management
      ApiToken: RealApiToken,
      // Library (central icon repository)
      LibraryIcon: RealLibraryIcon,
      // Backup & Restore
      Backup: RealBackup,
      BackupSettings: RealBackupSettings,
      BrandingSettings: RealBrandingSettings,
      RestoreLog: RealRestoreLog,
      BackupNotificationLog: RealBackupNotificationLog,
      // Two-Factor Authentication
      UserTwoFactor: RealUserTwoFactor,
      TrustedDevice: RealTrustedDevice,
      TwoFactorChallenge: RealTwoFactorChallenge,
      TwoFactorPolicy: RealTwoFactorPolicy,
      // Reputation & Reviews
      Complaint: RealComplaint,
      ReputationReview: RealReputationReview,
      MediaMention: RealMediaMention,
      // Email Dispatch
      EmailDispatch: RealEmailDispatch,
      // BrandKit
      BrandKit: RealBrandKit,
      BrandKitTemplate: RealBrandKitTemplate,
      BrandKitAsset: RealBrandKitAsset,
      BrandKitOrder: RealBrandKitOrder,
    };
  }

  return models;
};

// Export getter functions that load models dynamically
export const getModels = () => loadModels();

// Re-export PR model types
export type { IExpertColumn, ExpertColumnFormat, ContentTone as PrContentTone, ContentWordCount as PrContentWordCount } from './ExpertColumn';
export type { IExpertColumnPlan } from './ExpertColumnPlan';
export type { IPressRelease, PressReleaseEventType, PressReleaseWordCount } from './PressRelease';
export type { IFounderBio, BioType } from './FounderBio';
export type { IMediaKit } from './MediaKit';

// Re-export types
export type { IUser, UserRole, UserStatus } from './User';
export type { IRole, IPermission } from './Role';
export type { IUserAccessOverride } from './UserAccessOverride';
export type { IAuditLog } from './AuditLog';
export type { IActivityLog, ActivityStatus } from './ActivityLog';
export type {
  INotification,
  NotificationCategory,
  NotificationPriority,
  NotificationAudienceRole,
  NotificationChannel,
} from './Notification';
export type {
  INotificationPreference,
  ICategoryChannelPreference,
  DigestFrequency,
} from './NotificationPreference';
export type { IBackup } from './Backup';
export type { IBackupSettings } from './BackupSettings';
export type { IBrandingSettings, IBrandingColors, IBrandingLogos, AppearanceMode, LayoutDensity, BorderRadiusScale, FontSizeScale } from './BrandingSettings';
export type { IRestoreLog } from './RestoreLog';
export type { IBackupNotificationLog, BackupNotificationType } from './BackupNotificationLog';
export type { IUserTwoFactor, IRecoveryCodeEntry, TwoFactorStatus, TwoFactorMethod } from './UserTwoFactor';
export type { ITrustedDevice } from './TrustedDevice';
export type { ITwoFactorChallenge, ChallengePurpose } from './TwoFactorChallenge';
export type { ITwoFactorPolicy } from './TwoFactorPolicy';
export type { IComplaint, ComplaintSeverity, ComplaintStatus } from './Complaint';
export type { IReputationReview, ReviewPlatform, ReviewStatus } from './ReputationReview';
export type { IMediaMention, MentionType, SentimentType } from './MediaMention';
export type { IEmailDispatch, EmailDispatchStatus } from './EmailDispatch';
export type { ICompany } from './Company';
export type { IBusinessProfile } from './BusinessProfile';
export type { IProduct, IProductCategory } from './Product';
export type { IFounder } from './Founder';
export type { IEmployee } from './Employee';
export type { IICP } from './ICP';
export type { IPersona } from './Persona';
export type { ICompetitor } from './Competitor';
export type { IBrand } from './Brand';
export type { IBrandAsset } from './BrandAsset';
export type { IStationery } from './Stationery';
export type { IStationeryTemplate, PlaceholderRegion, TemplateKind, TemplateSource, TemplateScope, TemplateStatus, PlaceholderType } from './StationeryTemplate';
export type { IWebsitePage } from './WebsitePage';
export type { IBlog } from './Blog';
export type { IBlogContentOS } from './BlogContentOS';
export type { INewsletterContentOS } from './NewsletterContentOS';
export type { INewsletter } from './Newsletter';
export type { ILandingPageContentOS } from './LandingPageContentOS';
export type { IFAQ, IFAQCategory } from './FAQ';
export type { ITestimonial, TestimonialType, TestimonialStatus, CollectionMethod, AuthorityLevel, DetailDepth } from './Testimonial';
export type { ISalesScript, ScriptType, ScriptStatus, FunnelStage, AudienceType, CommunicationChannel, ScriptPriority } from './SalesScript';
export type { ISalesCollateral, CollateralType, CollateralStatus, CollateralCategory, SalesStage, CollateralAccessLevel } from './SalesCollateral';
export type { IVideoContent, VideoType, VideoCategory, VideoSource, VideoStatus, VideoAccessLevel, WatchStatus } from './VideoContent';
export type { IAudioContent, AudioGenre, AudioMood, AudioSingerType, AudioLanguage, AudioContentStatus } from './AudioContent';
export type { IWhatsAppCampaign, WhatsAppCampaignStatus, WhatsAppCampaignGoal, NurturingFramework, MessageTone, PersonalizationLevel, MessageLength, DataSourceKey, ContentBlockType, TriggerEvent, ExitCondition, WhatsAppMessageStatus, MessageFrequency } from './WhatsAppCampaign';
export type { IAdCampaign, AdCampaignStatus, AdCampaignGoal } from './AdCampaign';
export type { IAd, AdPlatform as AdPlatformModel } from './Ad';
export type { IAdAudience } from './AdAudience';
export type { IAdBudget } from './AdBudget';
export type { IAdCreativeAsset } from './AdCreativeAsset';
export type { IAdABTest } from './AdABTest';
export type { IAdAIRecommendation } from './AdAIRecommendation';
export type { IEventCategory, EventCategoryStatus, IEvent, EventStatus, EventVisibility, EventPriority, EventMode, EventType as EventEventType, EventAudienceType, ApprovalStatus, IEventSession, SessionStatus, IEventResource, ResourceType, ResourceStatus } from './Event';
export type { IAward, AwardType, AwardStatus, AwardCategory } from './Award';
export type { IIntroScript, IntroductionType, EventType as IntroScriptEventType, IntroScriptLanguage, IntroScriptDuration, IntroScriptTone, IntroScriptContext, IntroScriptSource, IntroScriptStatus } from './IntroScript';
export type { ICaseStudyCategory, CaseStudyCategoryStatus, ICaseStudy, CaseStudyStatus, CaseStudyPriority, CaseStudyVisibility, CaseStudyIndustry, CaseStudyDepartment } from './CaseStudy';
export type { IAiContext, IAiContextInputs, IAiAnalysisResult, AiContextStatus } from './AiContext';
export type { IAiGeneratedVersion } from './AiGeneratedVersion';
export type { IModuleData } from './ModuleData';
export type { IChatSession, IChatMessage } from './ChatSession';
// Subscription & Billing types
export type { ISubscriptionPackage, SubscriptionPackageCurrency } from './SubscriptionPackage';
export type { ICompanySubscription, SubscriptionStatus, BillingCycle, PaymentGateway as PaymentGatewayType } from './CompanySubscription';
export type { IPaymentGatewayConfig, GatewayMode, IStripeConfig, IRazorpayConfig } from './PaymentGatewayConfig';
export type { ISmtpConfig, SmtpProviderId, SmtpEncryption } from './SmtpConfig';
export type { ICurrencyConfig } from './CurrencyConfig';
export type { IInvoice, InvoiceStatus } from './Invoice';
export type { ISubscriptionAuditLog, SubscriptionAction } from './SubscriptionAuditLog';
// Dynamic Pricing Engine types
export type { IPricingCategory, PricingCategorySelectionType } from './PricingCategory';
export type { IPricingItem, PricingItemMode, IPricingTier } from './PricingItem';
export type { IPricingRule, PricingRuleType, PricingRuleEffectType, PricingRuleApplyTo, PricingRuleStacking } from './PricingRule';
export type { IPricingDiscount, PricingDiscountType } from './PricingDiscount';
export type { IPricingTax } from './PricingTax';
export type { IPricingAddon, PricingAddonMode } from './PricingAddon';
// Google Business Profile (GMB) types
export type { IGmbLocation, ConnectionStatus as GmbConnectionStatus, VerificationStatus as GmbVerificationStatus, LocationStatus as GmbLocationStatus } from './GmbLocation';
export type { IGmbPost, GmbPostType, GmbPostStatus, GmbPostCtaType as GmbCtaType } from './GmbPost';
export type { IGmbReview, ReplyStatus as GmbReviewStatus } from './GmbReview';
export type { IGmbMedia, GmbMediaType, GmbMediaStatus } from './GmbMedia';
export type { IGmbInsight, GmbInsightPeriod } from './GmbInsight';
export type { IGmbAiContent, GmbAiContentType, GmbAiContentStatus } from './GmbAiContent';
export type { IGmbReport, GmbReportType, GmbReportFormat, GmbReportStatus } from './GmbReport';
export type { IGoogleDriveToken, GoogleDriveConnectionStatus } from './GoogleDriveToken';
export type { IN8nConfig, N8nConfigStatus } from './N8nConfig';
export type { IZapierConfig, ZapierConfigStatus } from './ZapierConfig';
export type { IYouTubeAccount, YouTubeAccountStatus } from './YouTubeAccount';
export type { IYouTubeAppConfig } from './YouTubeAppConfig';
export type { ISocialMediaPublication, PublicationPlatform, PublicationStatus as SocialPublicationStatus, PublicationPrivacy, PublicationPostType } from './SocialMediaPublication';
export type { IFacebookAccount, FacebookAccountStatus } from './FacebookAccount';
export type { IFacebookN8nConfig, FacebookN8nConfigStatus } from './FacebookN8nConfig';
export type { IFacebookAppConfig } from './FacebookAppConfig';
export type { IInstagramN8nConfig, InstagramN8nConfigStatus } from './InstagramN8nConfig';
export type { IThreadsN8nConfig, ThreadsN8nConfigStatus } from './ThreadsN8nConfig';
export type { IInstagramAccount, InstagramAccountStatus } from './InstagramAccount';
export type { ILinkedInAccount, LinkedInAccountStatus, LinkedInAccountType } from './LinkedInAccount';
export type { ILinkedInAppConfig } from './LinkedInAppConfig';
export type { ITwitterAccount, TwitterAccountStatus, TwitterAccountType } from './TwitterAccount';
export type { ITwitterAppConfig } from './TwitterAppConfig';
export type { IThreadsAccount, ThreadsAccountStatus, ThreadsAccountType } from './ThreadsAccount';
export type { IPinterestAccount, PinterestAccountStatus, PinterestAccountType } from './PinterestAccount';
export type { IPinterestAppConfig } from './PinterestAppConfig';
export type { IGoogleAdsAppConfig } from './GoogleAdsAppConfig';
export type { IGoogleBusinessProfileConfig, GBPConfigStatus } from './GoogleBusinessProfileConfig';
export type { IWordPressConfig, WordPressConfigStatus } from './WordPressConfig';
export type { IMetaAdsAppConfig } from './MetaAdsAppConfig';
export type { IWhatsAppAppConfig } from './WhatsAppAppConfig';
export type { IWhatsAppConnection, WhatsAppConnectionStatus } from './WhatsAppConnection';
// Blogger (Google/Blogger integration)
export type { IBloggerAppConfig } from './BloggerAppConfig';
export type { IBloggerAccount, BloggerAccountStatus, IBloggerBlog } from './BloggerAccount';
export type { IThreadsAppConfig } from './ThreadsAppConfig';
// Blog Generation
export type {
  IBlogGeneration,
  BlogGenerationPhase,
  BlogGenerationStatus,
  BlogFrameworkType,
  BlogTone,
  BlogReadingLevel,
  BlogCTAFrequency,
  ExportFormatType,
} from './BlogGeneration';

// GEO Optimization
export type { IGEOOptimization, GEOContentType, GEOStatus } from './GEOOptimization';
// GEO Intelligence
export type {
  IGeoAuditSnapshot,
  IGeoPlatformMetric,
  IGeoCitationOpportunity,
  IGeoRecommendation,
  IGeoSimulationRun,
  IGeoAuditSettings,
  GeoScoreKey,
  GeoAuditType,
  GeoAuditFrequency,
  GeoOpportunityStatus,
  GeoRecommendationStatus,
} from './GeoIntelligence';
// Social Media Campaign
export type { ISocialMediaCampaign, SocialMediaCampaignStatus } from './SocialMediaCampaign';
// Guerrilla Campaign
export type { IGuerrillaCampaign, GuerrillaCampaignStatus, GuerrillaCampaignCategory, GuerrillaCampaignGoal } from './GuerrillaCampaign';
// Wikipedia & Knowledge Panel
export type { IWikipediaArticle, WikipediaArticleStatus, CitationType, CitationReliability, CitationIndependence, CitationStatus, EditType, INotabilityCriterion, IArticleSection, ICitation, ISubmissionEntry, IMonitorAlert } from './WikipediaArticle';
export type { IKnowledgePanel, KnowledgePanelStatus, AttributePriority, VerificationStepStatus, OptimisationPriority, OptimisationStatus, ChangeType, IPanelAttribute, IPanelData, IVerificationStep, IOptimisation, IChangeLogEntry, ITopAction } from './KnowledgePanel';
// Image Generation
export type {
  IImageGeneration,
  IImageGenerationVersion,
  ImageStyle,
  ImagePlatform,
  ImageAspectRatio,
  ImageGenerationStatus,
  ImageQuality,
  DallEStyle,
} from './ImageGeneration';

// Interview & Media Prep
export type {
  IInterviewMediaPrep,
  IInterviewSession,
  IInterviewQuestion,
  ICoachingTip,
  PrepType,
  SpeakerType,
  DifficultyLevel,
  AudienceType as InterviewAudienceType,
  Language as PrepLanguage,
  InterviewStatus,
} from './InterviewMediaPrep';
// Speaking Engagement Memory (anti-repetition)
export type { ISpeakingEngagementMemory } from './SpeakingEngagementMemory';
// Marketing Calendar & Timing
export type {
  IMarketingCalendarEvent,
  CalendarEventType,
  CalendarPriority,
  CalendarRecurrence,
  CalendarEventStatus,
  ISeasonalPlan,
  SeasonType,
  SeasonalPlanStatus,
} from './MarketingCalendar';

// Marketing Channels Map
export type {
  IMarketingChannel,
  ChannelType as MarketingChannelType,
  ChannelStatus,
  ChannelPriority,
  IChannelMap,
  ChannelMapStatus,
  FunnelStage as MarketingChannelFunnelStage,
  AudienceRole,
  TouchpointType,
} from './MarketingChannel';
// Funding Module Types
export type {
  IPitchDeck,
  IPitchDeckSlide,
  IPitchDeckVersion,
  IPitchDeckLinkedData,
  DeckStatus,
  DeckTemplate,
  PitchDeckSlideType,
  PitchDeckSlideLayout,
} from './PitchDeck';

export type {
  IFinancialModel,
  IRevenueStream,
  ICostCategory,
  IUnitEconomics,
  IHeadcountPlanEntry,
  IFundingAssumptions,
  IFinancialScenario,
  IAINarrative,
  ModelStatus,
  RevenueType,
  ScenarioType,
  CostType,
} from './FinancialModel';

export type {
  IInvestor,
  IInvestmentThesis,
  IInvestorInteraction,
  ITermSheetData,
  IWarmIntro,
  InvestorStage,
  InvestorType,
  CheckSize,
  InvestorPriority,
} from './Investor';

export type {
  IFundingRound,
  ICommitment,
  IRoundTerms,
  IRoundDocument,
  RoundStatus,
  RoundType,
  CommitmentStatus,
} from './FundingRound';

export type {
  ICapTable,
  IShareholder,
  IVestingSchedule,
  IOptionDetails,
  IDilutionScenario,
  ICapTableHistory,
  ICapTableDocument,
  IOptionPool,
  ShareholderType,
  ShareClass,
  VestingType,
} from './CapTable';
// MOAT Analysis
export type { IMoatAnalysis, MoatStatus, MoatSource } from './MoatAnalysis';
// SWOT Analysis
export type { ISwotAnalysis, SwotStatus, SwotSource } from './SwotAnalysis';
// Presentations & Pitches
export type {
  IPresentation,
  IPresentationSlide,
  IPresentationVersion,
  IPresentationDataSource,
  PresentationType,
  PresentationTone,
  PresentationStatus,
  PresentationSlideLayout,
  PresentationSlideType,
} from './Presentation';
// Prompt Config
export type { IPromptConfig, PromptConfigType } from './PromptConfig';
// Sales Performance
export type { ICommissionPlan, PlanType as CommissionPlanType, PayoutFrequency } from './CommissionPlan';
export type { ICommission, CommissionStatus, CommissionType } from './Commission';
export type { ICommissionPayout } from './CommissionPayout';
export type { ISalesQuota, QuotaPeriod, QuotaType, QuotaStatus as TargetStatus } from './SalesQuota';
export type { ITeamQuota } from './TeamQuota';
export type { ISalesDashboard, DashboardType as ReportType, DashboardLayout } from './SalesDashboard';
export type { IProposal, ProposalStatus, ProposalType } from './Proposal';
// Feature Request
export type { IFeatureRequest, FeatureRequestStatus, FeatureRequestPriority, FeatureRequestCategory } from './FeatureRequest';
export type { IFeatureRequestComment } from './FeatureRequestComment';
export type { IFeatureRequestNotificationLog, FeatureRequestActivityType } from './FeatureRequestNotificationLog';
export type { ITemplateStyle, TemplateLayoutType } from './TemplateStyle';
// Executive CV
export type {
  IExecutiveCV,
  CVStatus,
  IProfessionalExperience,
  ICVProject,
  IInterviewMedia,
  ISpeakingEngagementCV,
  IFundingHighlight,
  IPresentationHighlight,
  IGeneratedCV,
  IDataSourceSelections,
} from './ExecutiveCV';
// Wikipedia Profile
export type { IWikipediaProfile, WikipediaProfileType, IWikipediaCompanyProfile, IWikipediaFounderProfile, IWikipediaEmployeeProfile } from './WikipediaProfile';
// Email Signature
export type { IEmailSignature, EmailSignatureProfileType, EmailSignatureStatus } from './EmailSignature';
export type { ISignatureTemplate, SignatureTemplateStatus } from './SignatureTemplate';
export type { INewsletterTemplate, NewsletterTemplateStatus } from './NewsletterTemplate';
// Email Integration (Brevo)
export type { IEmailIntegration, EmailProvider, ConnectionStatus } from './EmailIntegration';
export type { IEmailCampaign, CampaignSyncStatus, ICampaignStats } from './EmailCampaign';
export type { IEmailContact, ContactStatus } from './EmailContact';
// Automation Workflows
export type {
  IAutomationWorkflow,
  IAutomationInstance,
  IAutomationLog,
  IWorkflowTrigger,
  IWorkflowNode,
  IWorkflowEdge,
  IWorkflowSettings,
  IWorkflowStats,
  ITriggerFilter,
  ICondition,
  IConditionGroup,
  INodeConfig,
  INodeExecutionState,
  IInstanceError,
  TriggerType,
  NodeType,
  WorkflowStatus,
  InstanceStatus,
  ConditionOperator,
} from './AutomationWorkflow';
// Email Designer Templates
export type { IEmailDesignerTemplate, IEmailBlock, IEmailDesignSettings, EmailDesignerTemplateStatus } from './EmailDesignerTemplate';
// API Token Management
export type { IApiToken, ApiTokenStatus } from './ApiToken';
// Library (central icon repository)
export type { ILibraryIcon, LibraryIconType } from './LibraryIcon';
// BrandKit
export type { IBrandKit, BrandKitStatus } from './BrandKit';
export type { IBrandKitTemplate, BrandKitAssetType, TemplateKind as BrandKitTemplateKind, TemplateSource as BrandKitTemplateSource, TemplateScope as BrandKitTemplateScope, TemplateStatus as BrandKitTemplateStatus, PlaceholderType as BrandKitPlaceholderType, PlaceholderRegion as BrandKitPlaceholderRegion } from './BrandKitTemplate';
export type { IBrandKitAsset, BrandKitAssetStatus } from './BrandKitAsset';
export type { IBrandKitOrder, IOrderItem, OrderStatus as BrandKitOrderStatus, PaymentStatus, PaymentGateway as BrandKitPaymentGateway } from './BrandKitOrder';