// auth.proto
service AuthService {
  rpc Register(RegisterRequest) returns (AuthResponse) {}
  rpc Login(LoginRequest) returns (AuthResponse) {}
  rpc Refresh(RefreshRequest) returns (AuthResponse) {}
  rpc VerifyEmail(VerifyEmailRequest) returns (Empty) {}
}

message RegisterRequest {
  string email = 1;
  string password = 2;
  string firstName = 3;
  string lastName = 4;
  string profession = 5;
}

message AuthResponse {
  string accessToken = 1;
  string refreshToken = 2;
  string userId = 3;
  string userEmail = 4;
  int64 expiresAt = 5;
}

// document.proto
service DocumentService {
  rpc CreateDocument(CreateDocumentRequest) returns (DocumentResponse) {}
  rpc GetDocument(GetDocumentRequest) returns (DocumentResponse) {}
  rpc ListDocuments(ListDocumentsRequest) returns (DocumentsResponse) {}
  rpc UpdateDocument(UpdateDocumentRequest) returns (DocumentResponse) {}
  rpc DeleteDocument(DeleteDocumentRequest) returns (Empty) {}
}

message CreateDocumentRequest {
  string title = 1;
  string description = 2;
  string contentType = 3;
  bytes content = 4;
  repeated string categories = 5;
  map<string, string> metadata = 6;
}

message DocumentResponse {
  string id = 1;
  string title = 2;
  string description = 3;
  string url = 4;
  string thumbnailUrl = 5;
  string authorId = 6;
  repeated string categories = 7;
  map<string, string> metadata = 8;
  int64 createdAt = 9;
  int64 updatedAt = 10;
}

-- documents table
CREATE TABLE documents (
    id UUID PRIMARY KEY,
    title TEXT NOT NULL,
    description TEXT,
    url TEXT NOT NULL,
    thumbnail_url TEXT,
    content_type TEXT NOT NULL,
    file_size INT NOT NULL,
    author_id UUID NOT NULL,
    is_private BOOLEAN DEFAULT FALSE,
    expires_at TIMESTAMPTZ,
    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
    
    -- Indexes
    INDEX idx_documents_title (title),
    INDEX idx_documents_categories (categories),
    FOREIGN KEY (author_id) REFERENCES users(id)
);

-- repair_solutions table
CREATE TABLE repair_solutions (
    id UUID PRIMARY KEY,
    title TEXT NOT NULL,
    problem_description TEXT NOT NULL,
    solution_steps TEXT NOT NULL,
    warning_notes TEXT,
    tags TEXT[],
    author_id UUID NOT NULL,
    synth_model TEXT,
    difficulty_level INT CHECK (difficulty_level BETWEEN 1 AND 5),
    estimated_time TEXT,
    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
    
    INDEX idx_repair_solutions_tags (tags),
    FOREIGN KEY (author_id) REFERENCES users(id)
);

-- forum_threads table
CREATE TABLE forum_threads (
    id UUID PRIMARY KEY,
    title TEXT NOT NULL,
    content TEXT NOT NULL,
    author_id UUID NOT NULL,
    category TEXT NOT NULL,
    views INT DEFAULT 0,
    is_pinned BOOLEAN DEFAULT FALSE,
    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
    
    INDEX idx_forum_category (category),
    FOREIGN KEY (author_id) REFERENCES users(id)
);

-- comments table
CREATE TABLE comments (
    id UUID PRIMARY KEY,
    content TEXT NOT NULL,
    author_id UUID NOT NULL,
    post_id UUID NOT NULL,
    parent_comment_id UUID,
    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
    
    FOREIGN KEY (author_id) REFERENCES users(id),
    FOREIGN KEY (post_id) REFERENCES forum_threads(id),
    FOREIGN KEY (parent_comment_id) REFERENCES comments(id)
);

// notify/websocket.go
type NotificationService struct {
    broadcaster *broadcaster.Broadcaster
}

func (s *NotificationService) HandleWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Error("Failed to upgrade", "error", err)
        return
    }
    
    userID := r.Context().Value("userID").(string)
    if userID == "" {
        conn.Close()
        return
    }
    
    s.broadcaster.AddConnection(userID, conn)
    defer s.broadcaster.RemoveConnection(userID, conn)
    
    go func() {
        for {
            _, msg, err := conn.ReadMessage()
            if err != nil {
                break
            }
            // Handle incoming messages
        }
    }()
}

func (s *NotificationService) Broadcast(event string, payload map[string]interface{}) {
    s.broadcaster.Broadcast(event, payload)
}

// components/documents/DocumentUpload.tsx
import { useState, useCallback } from 'react';
import { useDocument } from '../hooks/useDocument';
import { Button } from './ui/Button';
import { Input } from './ui/Input';
import { Textarea } from './ui/Textarea';
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from './ui/Select';

export function DocumentUpload() {
  const [title, setTitle] = useState('');
  const [description, setDescription] = useState('');
  const [file, setFile] = useState<File | null>(null);
  const [categories, setCategories] = useState<string[]>([]);
  const [isLoading, setIsLoading] = useState(false);
  const [error, setError] = useState('');
  
  const { createDocument } = useDocument();
  
  const handleFileChange = useCallback((e: React.ChangeEvent<HTMLInputElement>) => {
    if (e.target.files && e.target.files[0]) {
      setFile(e.target.files[0]);
    }
  }, []);
  
  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    setError('');
    setIsLoading(true);
    
    if (!title.trim()) {
      setError('Title is required');
      return;
    }
    
    if (!file) {
      setError('File is required');
      return;
    }
    
    try {
      const formData = new FormData();
      formData.append('title', title);
      formData.append('description', description);
      formData.append('file', file);
      formData.append('categories', categories.join(','));
      
      await createDocument(formData);
      
      // Success handling
      alert('Document uploaded successfully!');
      // Reset form
      setTitle('');
      setDescription('');
      setFile(null);
      setCategories([]);
    } catch (err) {
      setError('Failed to upload document. Please try again.');
      console.error(err);
    } finally {
      setIsLoading(false);
    }
  };
  
  return (
    <div className="max-w-4xl mx-auto p-4">
      <h2 className="text-2xl font-bold mb-6">Upload New Document</h2>
      
      {error && <div className="mb-4 text-red-500">{error}</div>}
      
      <form onSubmit={handleSubmit} className="space-y-4">
        <div>
          <label htmlFor="title" className="block text-sm font-medium mb-1">
            Document Title
          </label>
          <Input
            id="title"
            value={title}
            onChange={(e) => setTitle(e.target.value)}
            placeholder="e.g., Roland JD-XA Service Manual"
            required
          />
        </div>
        
        <div>
          <label htmlFor="description" className="block text-sm font-medium mb-1">
            Description
          </label>
          <Textarea
            id="description"
            value={description}
            onChange={(e) => setDescription(e.target.value)}
            placeholder="Provide a brief description of this document..."
            rows={4}
          />
        </div>
        
        <div>
          <label htmlFor="file" className="block text-sm font-medium mb-1">
            Upload File
          </label>
          <div className="flex items-center gap-2">
            <Input
              id="file"
              type="file"
              onChange={handleFileChange}
              className="file:cursor-pointer file:bg-blue-500 file:text-white file:px-4 file:py-2 file:rounded-md"
            />
            {file && (
              <div className="text-sm text-gray-500">
                Selected: {file.name} ({(file.size / 1024).toFixed(2)} KB)
              </div>
            )}
          </div>
        </div>
        
        <div>
          <label className="block text-sm font-medium mb-1">Categories</label>
          <Select onValueChange={(value: string) => setCategories(prev => [...prev, value])}>
            <SelectTrigger>
              <SelectValue placeholder="Select categories" />
            </SelectTrigger>
            <SelectContent>
              <SelectItem value="synthesizers">Synthesizers</SelectItem>
              <SelectItem value="effects">Effects Units</SelectItem>
              <SelectItem value="amplifiers">Amplifiers</SelectItem>
              <SelectItem value="mixers">Mixers</SelectItem>
              <SelectItem value="recording">Recording Equipment</SelectDefined>
            </SelectContent>
          </Select>
          {categories.length > 0 && (
            <div className="mt-2 flex flex-wrap gap-2">
              {categories.map((cat, i) => (
                <span key={i} className="bg-blue-100 text-blue-800 text-xs px-3 py-1 rounded-full">
                  {cat.charAt(0).toUpperCase() + cat.slice(1)}
                  <button 
                    type="button" 
                    onClick={() => setCategories(categories.filter(c => c !== cat))}
                    className="ml-2 text-blue-500 hover:text-blue-700"
                  >
                    ×
                  </button>
                </span>
              ))}
            </div>
          )}
        </div>
        
        <Button type="submit" disabled={isLoading}>
          {isLoading ? 'Uploading...' : 'Upload Document'}
        </Button>
      </form>
    </div>
  );
}

// components/documents/DocumentCard.tsx
import { useState } from 'react';
import { Card, CardHeader, CardTitle, CardContent } from './ui/Card';
import { Button } from './ui/Button';
import { Download, Eye, Edit, Trash, Lock } from 'lucide-react';
import type { Document } from '../types/document';

interface DocumentCardProps {
  document: Document;
  onEdit?: (document: Document) => void;
  onDelete?: (id: string) => void;
}

export function DocumentCard({ document, onEdit, onDelete }: DocumentCardProps) {
  const [isPrivate, setIsPrivate] = useState(document.is_private);
  
  return (
    <Card className="overflow-hidden">
      <CardHeader className="bg-gradient-to-r from-blue-500 to-purple-600 text-white">
        <CardTitle className="flex items-center justify-between">
          <span>{document.title}</span>
          {document.is_private ? (
            <Lock className="w-5 h-5" />
          ) : (
            <Eye className="w-5 h-5" />
          )}
        </CardTitle>
      </CardHeader>
      <CardContent>
        <div className="mb-4">
          <p className="text-sm text-gray-600 line-clamp-2">{document.description}</p>
        </div>
        
        <div className="flex flex-wrap gap-2 mb-4">
          {document.categories.map((category, i) => (
            <span key={i} className="text-xs px-2 py-1 bg-blue-100 text-blue-800 rounded">
              {category}
            </span>
          ))}
        </div>
        
        <div className="flex justify-between items-center">
          <div className="text-sm text-gray-500">
            By {document.author.name} • {document.file_size} KB
          </div>
          
          <div className="flex gap-2">
            <Button variant="ghost" size="icon">
              <Download className="w-4 h-4" />
            </Button>
            {onEdit && (
              <Button variant="ghost" size="icon">
                <Edit className="w-4 h-4" />
              </Button>
            )}
            {onDelete && (
              <Button variant="ghost" size="icon">
                <Trash className="w-4 h-4" />
              </Button>
            )}
          </div>
        </div>
      </CardContent>
    </Card>
  );
}

// contexts/AuthContext.tsx
import { createContext, useContext, useState, useEffect, useCallback } from 'react';
import { authService } from '../services/api';

interface AuthState {
  user: User | null;
  isAuthenticated: boolean;
  isLoading: boolean;
  error: string | null;
}

interface AuthContextType extends AuthState {
  login: (email: string, password: string) => Promise<void>;
  register: (data: RegisterRequest) => Promise<void>;
  logout: () => void;
  refresh: () => Promise<void>;
}

const AuthContext = createContext<AuthContextType | undefined>(undefined);

export function AuthProvider({ children }: { children: React.ReactNode }) {
  const [state, setState] = useState<AuthState>({
    user: null,
    isAuthenticated: false,
    isLoading: true,
    error: null,
  });
  
  const login = useCallback(async (email: string, password: string) => {
    try {
      const response = await authService.login({ email, password });
      // Save tokens to localStorage/sessionStorage
      // Update state
      setState({
        ...state,
        user: response.user,
        isAuthenticated: true,
        isLoading: false,
        error: null,
      });
    } catch (err) {
      setState({
        ...state,
        error: 'Login failed. Please check your credentials.',
      });
    }
  }, [state]);
  
  const register = useCallback(async (data: RegisterRequest) => {
    try {
      await authService.register(data);
      // Auto-login after registration
      await login(data.email, data.password);
    } catch (err) {
      setState({
        ...state,
        error: 'Registration failed. Please try again.',
      });
    }
  }, [login, state]);
  
  const logout = useCallback(() => {
    // Clear tokens
    setState({
      user: null,
      isAuthenticated: false,
      isLoading: false,
      error: null,
    });
  }, []);
  
  const refresh = useCallback(async () => {
    // Check token validity and refresh if needed
  }, []);
  
  useEffect(() => {
    // Check auth token on app load
    const token = localStorage.getItem('accessToken');
    if (token) {
      // Verify token and fetch user data
    }
  }, []);
  
  return (
    <AuthContext.Provider value={{ ...state, login, register, logout, refresh }}>
      {children}
    </AuthContext.Provider>
  );
}

export function useAuth() {
  const context = useContext(AuthContext);
  if (!context) {
    throw new Error('useAuth must be used within an AuthProvider');
  }
  return context;
}

// internal/search/elastic.go
package search

import (
    "context"
    "encoding/json"
    "fmt"
    
    "github.com/olivere/elastic/v7"
)

type ElasticsearchService struct {
    client *elastic.Client
    index  string
}

func NewElasticsearchService() (*ElasticsearchService, error) {
    client, err := elastic.NewClient(
        elastic.SetURL("http://localhost:9200"),
        elastic.SetBasicAuth("elastic", "your_password"),
        elastic.SetSniff(false),
    )
    if err != nil {
        return nil, fmt.Errorf("failed to create Elasticsearch client: %w", err)
    }
    
    // Check if index exists, create if not
    exists, err := client.IndexExists("synthtech_search").Do(context.Background())
    if err != nil {
        return nil, fmt.Errorf("failed to check index: %w", err)
    }
    
    if !exists {
        mapping := `
        {
            "settings": {
                "number_of_shards": 1,
                "number_of_replicas": 1
            },
            "mappings": {
                "properties": {
                    "title": {"type": "text", "analyzer": "standard"},
                    "content": {"type": "text", "analyzer": "standard"},
                    "description": {"type": "text", "analyzer": "standard"},
                    "categories": {"type": "keyword"},
                    "tags": {"type": "keyword"},
                    "author": {"type": "keyword"},
                    "created_at": {"type": "date"},
                    "document_id": {"type": "keyword"}
                }
            }
        }
        `
        _, err := client.CreateIndex("synthtech_search").BodyString(mapping).Do(context.Background())
        if err != nil {
            return nil, fmt.Errorf("failed to create index: %w", err)
        }
    }
    
    return &ElasticsearchService{
        client: client,
        index:  "synthtech_search",
    }, nil
}

func (s *ElasticsearchService) IndexDocument(document *Document) error {
    // Convert document to search index format
    body, _ := json.Marshal(map[string]interface{}{
        "title":       document.Title,
        "content":     document.Content,
        "description": document.Description,
        "categories":  document.Categories,
        "tags":        document.Tags,
        "author":      document.Author.Username,
        "created_at":  document.CreatedAt.Format(time.RFC3339),
        "document_id": document.ID,
    })
    
    _, err := s.client.Index().
        Index(s.index).
        Id(document.ID).
        BodyString(string(body)).
        Do(context.Background())
        
    return err
}

func (s *ElasticsearchService) Search(query string) (*SearchResponse, error) {
    searchBody := fmt.Sprintf(`
        {
            "query": {
                "multi_match": {
                    "query": "%s",
                    "fields": ["title^2", "content^1.5", "description^1"]
                }
            },
            "sort": [{"created_at": "desc"}],
            "from": 0,
            "size": 10
        }
    `, query)
    
    result, err := s.client.Search().
        Index(s.index).
        BodyString(searchBody).
        Do(context.Background())
    
    if err != nil {
        return nil, fmt.Errorf("search error: %w", err)
    }
    
    return &SearchResponse{
        Hits: result.Hits.Hits,
        Total: result.Hits.Total.Value,
    }, nil
}

// components/shared/SearchBar.tsx
import { useState, useEffect } from 'react';
import { useSearch } from '../hooks/useSearch';

interface SearchBarProps {
  onResults: (results: SearchHit[]) => void;
}

export function SearchBar({ onResults }: SearchBarProps) {
  const [query, setQuery] = useState('');
  const [debouncedQuery, setDebouncedQuery] = useState('');
  const [isLoading, setIsLoading] = useState(false);
  const [error, setError] = useState('');
  
  const { searchDocuments } = useSearch();
  
  useEffect(() => {
    const handler = setTimeout(() => {
      setDebouncedQuery(query);
    }, 300);
    
    return () => clearTimeout(handler);
  }, [query]);
  
  useEffect(() => {
    if (debouncedQuery.trim() === '') {
      onResults([]);
      return;
    }
    
    const search = async () => {
      setIsLoading(true);
      setError('');
      
      try {
        const results = await searchDocuments(debouncedQuery);
        onResults(results);
      } catch (err) {
        setError('Failed to search. Please try again.');
      } finally {
        setIsLoading(false);
      }
    };
    
    search();
  }, [debouncedQuery, onResults]);
  
  return (
    <div className="relative">
      <input
        type="text"
        value={query}
        onChange={(e) => setQuery(e.target.value)}
        placeholder="Search documents, repairs, and forum..."
        className="w-full p-3 pl-10 text-sm border rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500"
      />
      
      {isLoading && (
        <div className="absolute right-3 top-1/2 transform -translate-y-1/2">
          {/* Loading spinner */}
        </div>
      )}
      
      {error && <div className="text-red-500 text-sm mt-1">{error}</div>}
    </div>
  );
}

version: '3.8'

services:
  backend:
    build: ./synthtech-backend
    ports:
      - "8080:8080"
    environment:
      - PORT=8080
      - JWT_SECRET=your-secret-key
      - DATABASE_URL=postgres://postgres:password@postgres:5432/synthtech
      - ELASTICSEARCH_URL=http://elasticsearch:9200
    depends_on:
      - postgres
      - elasticsearch
    restart: unless-stopped
    
  frontend:
    build: ./synthtech-frontend
    ports:
      - "3000:3000"
    environment:
      - VITE_API_URL=http://backend:8080/api
    depends_on:
      - backend
    restart: unless-stopped
    
  postgres:
    image: postgres:15
    ports:
      - "5432:5432"
    environment:
      POSTGRES_DB: synthtech
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped
    
  elasticsearch:
    image: elasticsearch:8.10.3
    ports:
      - "9200:9200"
      - "9300:9300"
    environment:
      ELASTICSEARCH_NODE_NAME: synthtech-es
      ELASTICSEARCH_CLUSTER_NAME: synthtech-cluster
      ELASTICSEARCH_NETWORK_HOST: 0.0.0.0
      ELASTICSEARCH_DISCOVERY_TYPE: single-node
      ELASTICSEARCH_JAVA_OPTS: "-Xms1g -Xmx1g"
    volumes:
      - es_data:/usr/share/elasticsearch/data
    restart: unless-stopped
    
  minio:
    image: minio/minio:latest
    ports:
      - "9000:9000"
      - "9001:9001"
    environment:
      MINIO_ACCESS_KEY: minioadmin
      MINIO_SECRET_KEY: minioadminsecret
    command: server /data --console-address :9001
    volumes:
      - minio_data:/data
    restart: unless-stopped
    
  nginx:
    image: nginx:latest
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./certs:/etc/nginx/certs
    depends_on:
      - backend
      - frontend
    restart: unless-stopped

volumes:
  postgres_data:
  es_data:
  minio_data:

# nginx.conf
worker_processes  auto;
error_log  /var/log/nginx/error.log notice;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    upstream backend {
        least_conn;
        server backend:8080;
    }

    upstream frontend {
        least_conn;
        server frontend:3000;
    }

    server {
        listen 80;
        server_name synthtech.app www.synthtech.app;
        
        location / {
            proxy_pass http://frontend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }

        location /api/ {
            proxy_pass http://backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }

        location /static/ {
            alias /var/www/static/;
        }
        
        # WebSocket support
        location /ws/ {
            proxy_pass http://backend;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection "upgrade";
            proxy_set_header Host $host;
        }
        
        error_page 500 502 503 504 /50x.html;
        location = /50x.html {
            root /usr/share/nginx/html;
        }
    }

    server {
        listen 443 ssl;
        server_name synthtech.app www.synthtech.app;
        
        ssl_certificate /etc/nginx/certs/synthtech.crt;
        ssl_certificate_key /etc/nginx/certs/synthtech.key;
        
        # Same configuration as HTTP server
        copy-config-from-http-server-here...
    }
}

security:
  encryption:
    at_rest: AES-256-GCM (PostgreSQL)
    in_transit: TLS 1.3 (Let's Encrypt)
    keys_rotation: 90_days
  
  hashing:
    passwords: bcrypt (cost: 12)
    emails: Argon2id
  
  access_control:
    default_policy: deny-all
    rules:
      - resource: documents
        actions: ["read"]
        effect: allow
        conditions: ["is_public OR user_is_owner OR user_is_moderator"]

// pkg/middleware/rate_limit.go
package middleware

import (
    "net/http"
    "time"
    
    "github.com/golang-jwt/jwt/v5"
    "github.com/juju/ratelimit"
)

type RateLimitMiddleware struct {
    limiter *ratelimit.TokenBucket
}

func NewRateLimitMiddleware() *RateLimitMiddleware {
    return &RateLimitMiddleware{
        limiter: ratelimit.NewBucketWithRate(
            100, // 100 requests per second
            100, // capacity
        ),
    }
}

func (m *RateLimitMiddleware) Handle(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Skip rate limiting for health checks
        if r.URL.Path == "/health" {
            next.ServeHTTP(w, r)
            return
        }
        
        // Check if rate limit allows request
        if !m.limiter.Allow() {
            http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
            return
        }
        
        next.ServeHTTP(w, r)
    })
}

// icons.ts
export const Icons = {
  electronics: {
    synth: "svg:synth-icon",
    amplifier: "svg:amplifier-icon",
    effects: "svg:effects-icon",
    microphone: "svg:microphone-icon",
  },
  actions: {
    upload: "svg:upload-icon",
    download: "svg:download-icon",
    search: "svg:search-icon",
    filter: "svg:filter-icon",
    notifications: "svg:notifications-icon",
  },
  status: {
    active: "svg:active-icon",
    pending: "svg:pending-icon",
    approved: "svg:approved-icon",
    rejected: "svg:rejected-icon",
  },
};

// internal/moderation/service.go
package moderation

type ModerationService struct {
    // ... dependencies
}

func (m *ModerationService) FlagContent(contentID, userID, reason string) error {
    // Create flag record
    // Notify moderators
    // If auto-moderation rules match, take action
    
    return nil
}

func (m *ModerationService) ReviewFlags() ([]*Flag, error) {
    // Return pending flags for moderation team
    return nil, nil
}

func (m *ModerationService) TakeAction(contentID, action, moderatorID string) error {
    // Update content status based on action
    // 1 = approve, 2 = reject, 3 = remove, 4 = warn_user
    
    return nil
}

func (m *ModerationService) GetContentStatus(contentID string) (string, error) {
    // Return current content status
    return "", nil
}

// frontend/src/types/user.ts
interface User {
  id: string;
  username: string;
  reputation: number;
  level: number;
  experience: number;
  badges: string[];
  // ... other fields
}

interface ReputationChange {
  type: 'upvote' | 'downvote' | 'accept_answer' | 'publish_document' | 'moderation';
  amount: number;
  description: string;
  timestamp: string;
}