export default {
    ops: {
      title: 'Ops Monitoring',
      description: 'Operational monitoring and troubleshooting',
      // Dashboard
      systemHealth: 'System Health',
      overview: 'Overview',
      noSystemMetrics: 'No system metrics collected yet.',
      collectedAt: 'Collected at:',
      window: 'window',
      memory: 'Memory',
      db: 'DB',
      goroutines: 'Goroutines',
      jobs: 'Jobs',
      jobsHelp: 'Click “Details” to view job heartbeats and recent errors',
      active: 'active',
      idle: 'idle',
      waiting: 'waiting',
      conns: 'conns',
      queue: 'queue',
      accountSwitches: 'Account switches',
      ok: 'ok',
      lastRun: 'last_run:',
      lastSuccess: 'last_success:',
      lastError: 'last_error:',
      result: 'Result',
      noData: 'No data.',
      loadingText: 'loading',
      ready: 'ready',
      autoRefreshRemaining: 'Remaining {seconds}s',
      systemLogs: {
        title: 'System Logs',
        description: 'Newest logs are shown first. Filter, search, and clean up by condition.',
        queue: 'Queue',
        written: 'Written',
        dropped: 'Dropped',
        failed: 'Failed',
        runtimeConfig: 'Runtime Log Configuration (applies immediately)',
        all: 'All',
        level: 'Level',
        stacktraceThreshold: 'Stacktrace threshold',
        samplingInitial: 'Sampling initial',
        samplingThereafter: 'Sampling thereafter',
        retentionDays: 'Retention days',
        caller: 'caller',
        sampling: 'sampling',
        saveAndApply: 'Save and apply',
        resetDefaults: 'Reset defaults',
        latestWriteError: 'Latest write error:',
        timeRange: 'Time range',
        startTime: 'Start time (optional)',
        endTime: 'End time (optional)',
        host: 'Host',
        component: 'Component',
        componentPlaceholder: 'e.g. http.access',
        keyId: 'KEY ID',
        platform: 'Platform',
        model: 'Model',
        keyword: 'Keyword',
        keywordPlaceholder: 'message/request_id',
        search: 'Search',
        cleanCurrentFilters: 'Clean current filters',
        refreshHealth: 'Refresh health',
        empty: 'No system logs',
        time: 'Time',
        logDetails: 'Log Details',
        loadFailed: 'Failed to load system logs',
        runtimeConfigActive: 'Runtime log configuration is active',
        runtimeConfigSaveFailed: 'Failed to save log configuration',
        resetRuntimeConfigConfirm: 'Reset to startup configuration (env/yaml) and apply immediately?',
        runtimeConfigReset: 'Reset to startup log configuration',
        runtimeConfigResetFailed: 'Failed to reset log configuration',
        cleanupConfirm: 'Clean up system logs matching the current filters? This cannot be undone.',
        cleanupSuccess: 'Cleanup complete. Deleted {count} log entries.',
        cleanupFilterRequired: 'Cleanup requires at least one filter condition (start/end time or another field)',
        cleanupFailed: 'Failed to clean up system logs'
      },
      requestsTotal: 'Requests (total)',
      slaScope: 'SLA scope:',
      tokens: 'Tokens',
      tps: 'TPS:',
      current: 'current',
      peak: 'peak',
      average: 'average',
      totalRequests: 'Total Requests',
      avgQps: 'Avg QPS',
      avgTps: 'Avg TPS',
      avgLatency: 'Avg Request Duration',
      avgTtft: 'Avg TTFT',
      exceptions: 'Exceptions',
      requestErrors: 'Request Errors',
      errorCount: 'Error Count',
      upstreamErrors: 'Upstream Errors',
      errorCountExcl429529: 'Error Count (excl 429/529)',
      sla: 'SLA (excl business limits)',
      businessLimited: 'business_limited:',
      errors: 'Errors',
      errorRate: 'error_rate:',
      upstreamRate: 'upstream_rate:',
      latencyDuration: 'Request Duration',
      ttftLabel: 'TTFT (first_token_ms)',
      p50: 'p50:',
      p90: 'p90:',
      p95: 'p95:',
      p99: 'p99:',
      avg: 'avg:',
      max: 'max:',
      requests: 'Requests',
      requestsTitle: 'Requests',
      upstream: 'Upstream',
      client: 'Client',
      system: 'System',
      other: 'Other',
      errorsSla: 'Errors (SLA scope)',
      upstreamExcl429529: 'Upstream (excl 429/529)',
      failedToLoadData: 'Failed to load ops data.',
      failedToLoadOverview: 'Failed to load overview',
      failedToLoadThroughputTrend: 'Failed to load throughput trend',
      failedToLoadSwitchTrend: 'Failed to load avg account switches trend',
      failedToLoadLatencyHistogram: 'Failed to load request duration histogram',
      failedToLoadErrorTrend: 'Failed to load error trend',
      failedToLoadErrorDistribution: 'Failed to load error distribution',
      failedToLoadErrorDetail: 'Failed to load error detail',
      retryFailed: 'Retry failed',
      tpsK: 'TPS (K)',
      top: 'Top:',
      throughputTrend: 'Throughput Trend',
      switchRateTrend: 'Avg Account Switches',
      latencyHistogram: 'Request Duration Histogram',
      errorTrend: 'Error Trend',
      errorDistribution: 'Error Distribution',
      switchRate: 'Avg switches',
      // Health Score & Diagnosis
      health: 'Health',
      healthCondition: 'Health Condition',
      healthHelp: 'Overall system health score based on SLA, error rate, and resource usage',
      healthyStatus: 'Healthy',
      riskyStatus: 'At Risk',
      idleStatus: 'Idle',
      timeRange: {
        '5m': 'Last 5 minutes',
        '30m': 'Last 30 minutes',
        '1h': 'Last 1 hour',
        '1d': 'Last 1 day',
        '15d': 'Last 15 days',
        '6h': 'Last 6 hours',
        '24h': 'Last 24 hours',
        '7d': 'Last 7 days',
        '30d': 'Last 30 days',
        custom: 'Custom Range'
      },
      customTimeRange: {
        startTime: 'Start Time',
        endTime: 'End Time'
      },
      openaiTokenStats: {
        title: 'OpenAI Token Request Stats',
        viewModeTopN: 'TopN',
        viewModePagination: 'Pagination',
        prevPage: 'Previous',
        nextPage: 'Next',
        pageInfo: 'Page {page}/{total}',
        totalModels: 'Total models: {total}',
        failedToLoad: 'Failed to load OpenAI token stats',
        empty: 'No OpenAI token stats for the current filters',
        table: {
          model: 'Model',
          requestCount: 'Requests',
          avgTokensPerSec: 'Avg Tokens/sec',
          avgFirstTokenMs: 'Avg First Token Latency (ms)',
          totalOutputTokens: 'Total Output Tokens',
          avgDurationMs: 'Avg Duration (ms)',
          requestsWithFirstToken: 'Requests With First Token'
        }
      },
      fullscreen: {
        enter: 'Enter Fullscreen'
      },
      diagnosis: {
        title: 'Smart Diagnosis',
        footer: 'Automated diagnostic suggestions based on current metrics',
        idle: 'System is currently idle',
        idleImpact: 'No active traffic',
        // Resource diagnostics
        dbDown: 'Database connection failed',
        dbDownImpact: 'All database operations will fail',
        dbDownAction: 'Check database service status, network connectivity, and connection configuration',
        redisDown: 'Redis connection failed',
        redisDownImpact: 'Cache functionality degraded, performance may decline',
        redisDownAction: 'Check Redis service status and network connectivity',
        cpuCritical: 'CPU usage critically high ({usage}%)',
        cpuCriticalImpact: 'System response slowing, may affect all requests',
        cpuCriticalAction: 'Check CPU-intensive tasks, consider scaling or code optimization',
        cpuHigh: 'CPU usage elevated ({usage}%)',
        cpuHighImpact: 'System load is high, needs attention',
        cpuHighAction: 'Monitor CPU trends, prepare scaling plan',
        memoryCritical: 'Memory usage critically high ({usage}%)',
        memoryCriticalImpact: 'May trigger OOM, system stability threatened',
        memoryCriticalAction: 'Check for memory leaks, consider increasing memory or optimizing usage',
        memoryHigh: 'Memory usage elevated ({usage}%)',
        memoryHighImpact: 'Memory pressure is high, needs attention',
        memoryHighAction: 'Monitor memory trends, check for memory leaks',
        ttftHigh: 'Time to first token elevated ({ttft}ms)',
        ttftHighImpact: 'User perceived latency increased',
        ttftHighAction: 'Optimize request processing flow, reduce pre-processing time',
        // Error rate diagnostics
        upstreamCritical: 'Upstream error rate critically high ({rate}%)',
        upstreamCriticalImpact: 'May affect many user requests',
        upstreamCriticalAction: 'Check upstream service health, enable fallback strategies',
        upstreamHigh: 'Upstream error rate elevated ({rate}%)',
        upstreamHighImpact: 'Recommend checking upstream service status',
        upstreamHighAction: 'Contact upstream service team, prepare fallback plan',
        errorHigh: 'Error rate too high ({rate}%)',
        errorHighImpact: 'Many requests failing',
        errorHighAction: 'Check error logs, identify root cause, urgent fix required',
        errorElevated: 'Error rate elevated ({rate}%)',
        errorElevatedImpact: 'Recommend checking error logs',
        errorElevatedAction: 'Analyze error types and distribution, create fix plan',
        // SLA diagnostics
        slaCritical: 'SLA critically below target ({sla}%)',
        slaCriticalImpact: 'User experience severely degraded',
        slaCriticalAction: 'Urgently investigate errors and latency, consider rate limiting',
        slaLow: 'SLA below target ({sla}%)',
        slaLowImpact: 'Service quality needs attention',
        slaLowAction: 'Analyze SLA decline causes, optimize system performance',
        // Health score diagnostics
        healthCritical: 'Overall health score critically low ({score})',
        healthCriticalImpact: 'Multiple metrics may be degraded; prioritize error rate and latency investigation',
        healthCriticalAction: 'Comprehensive system check, prioritize critical-level issues',
        healthLow: 'Overall health score low ({score})',
        healthLowImpact: 'May indicate minor instability; monitor SLA and error rates',
        healthLowAction: 'Monitor metric trends, prevent issue escalation',
        healthy: 'All system metrics normal',
        healthyImpact: 'Service running stable'
      },
      // Error Log
      errorLog: {
        timeId: 'Time / ID',
        commonErrors: {
          contextDeadlineExceeded: 'context deadline exceeded',
          connectionRefused: 'connection refused',
          rateLimit: 'rate limit'
        },
        time: 'Time',
        type: 'Type',
        context: 'Context',
        platform: 'Platform',
        model: 'Model',
        group: 'Group',
        user: 'User',
        userId: 'User ID',
        apiKey: 'API Key',
        keyDeletedBadge: 'Key Deleted',
        account: 'Account',
        accountId: 'Account ID',
        status: 'Status',
        message: 'Message',
        ip: 'IP',
        latency: 'Request Duration',
        action: 'Action',
        noErrors: 'No errors in this window.',
        grp: 'GRP:',
        acc: 'ACC:',
        details: 'Details',
        phase: 'Phase',
        id: 'ID:',
        typeUpstream: 'Upstream',
        typeRequest: 'Request',
        typeAuth: 'Auth',
        typeAccountAuth: 'Account Auth',
        typeRouting: 'Routing',
        typeInternal: 'Internal',
        endpoint: 'Endpoint',
        requestType: 'Type',
        requestTypeSync: 'Sync',
        requestTypeStream: 'Stream',
        requestTypeWs: 'WS'
      },
      // Error Details Modal
      errorDetails: {
        upstreamErrors: 'Upstream Errors',
        requestErrors: 'Request Errors',
        unresolved: 'Unresolved',
        resolved: 'Resolved',
        viewErrors: 'Errors',
        viewExcluded: 'Excluded',
        statusCodeOther: 'Other',
        owner: {
          provider: 'Provider',
          client: 'Client',
          platform: 'Platform'
        },
        phase: {
          request: 'Request',
          auth: 'Auth',
          account_auth: 'Account Auth',
          routing: 'Routing',
          upstream: 'Upstream',
          network: 'Network',
          internal: 'Internal'
        },
        total: 'Total:',
        searchPlaceholder: 'Search request_id / client_request_id / message',
      },
      // Error Detail Modal
      errorDetail: {
        title: 'Error Detail',
        titleWithId: 'Error #{id}',
        noErrorSelected: 'No error selected.',
        resolution: 'Resolved:',
        failedToUpdateResolvedStatus: 'Failed to update resolved status',
        classificationKeys: {
          phase: 'Phase',
          owner: 'Owner',
          source: 'Source',
          resolvedAt: 'Resolved At',
          resolvedBy: 'Resolved By'
        },
        source: {
          upstream_http: 'Upstream HTTP'
        },
        upstreamKeys: {
          status: 'Status',
          message: 'Message',
          detail: 'Detail',
          upstreamErrors: 'Upstream Errors'
        },
        upstreamEvent: {
          account: 'Account',
          status: 'Status',
          requestId: 'Request ID'
        },
        responsePreview: {
          expand: 'Response (click to expand)',
          collapse: 'Response (click to collapse)'
        },
        loading: 'Loading…',
        requestId: 'Request ID',
        time: 'Time',
        phase: 'Phase',
        status: 'Status',
        message: 'Message',
        basicInfo: 'Basic Info',
        platform: 'Platform',
        model: 'Model',
        group: 'Group',
        user: 'User',
        account: 'Account',
        latency: 'Request Duration',
        businessLimited: 'Business Limited',
        requestPath: 'Request Path',
        inboundEndpoint: 'Inbound Endpoint',
        upstreamEndpoint: 'Upstream Endpoint',
        requestedModel: 'Requested Model',
        upstreamModel: 'Upstream Model',
        requestType: 'Request Type',
        requestTypeUnknown: 'Unknown',
        requestTypeSync: 'Sync',
        requestTypeStream: 'Stream',
        requestTypeWs: 'WebSocket',
        modelMapping: 'Model Mapping',
        timings: 'Timings',
        auth: 'Auth',
        routing: 'Routing',
        upstream: 'Upstream',
        response: 'Response',
        classification: 'Classification',
        errorBody: 'Error Body',
        trimmed: 'trimmed',
        markResolved: 'Mark resolved',
        markUnresolved: 'Mark unresolved',
        tabOverview: 'Overview',
        tabRequest: 'Request',
        tabResponse: 'Response',
        responseBody: 'Response',
        compareA: 'Compare A',
        compareB: 'Compare B',
        suggestion: 'Suggestion',
        suggestUpstream: 'Upstream instability: check account status or consider switching accounts',
        suggestRequest: 'Client request error: ask customer to fix request parameters',
        suggestAuth: 'Auth failed: verify API key/credentials',
        suggestPlatform: 'Platform error: prioritize investigation and fix',
        suggestGeneric: 'See details for more context',
        apiKeyPrefix: 'Key Prefix',
        keyDeletedBadge: 'Key Deleted'
      },
      requestDetails: {
        title: 'Request Details',
        details: 'Details',
        rangeLabel: 'Window: {range}',
        rangeMinutes: '{n} minutes',
        rangeHours: '{n} hours',
        empty: 'No requests in this window.',
        emptyHint: 'Try a different time range or remove filters.',
        failedToLoad: 'Failed to load request details',
        requestIdCopied: 'Request ID copied',
        copyFailed: 'Copy failed',
        copy: 'Copy',
        viewError: 'View Error',
        kind: {
          success: 'SUCCESS',
          error: 'ERROR'
        },
        table: {
          time: 'Time',
          kind: 'Kind',
          platform: 'Platform',
          model: 'Model',
          duration: 'Duration',
          status: 'Status',
          requestId: 'Request ID',
          actions: 'Actions'
        }
      },
      alertEvents: {
        title: 'Alert Events',
        description: 'Recent alert firing/resolution records (email-only)',
        loading: 'Loading...',
        empty: 'No alert events',
        loadFailed: 'Failed to load alert events',
        status: {
          firing: 'FIRING',
          resolved: 'RESOLVED',
          manualResolved: 'MANUAL RESOLVED'
        },
        detail: {
          title: 'Alert Detail',
          loading: 'Loading detail...',
          empty: 'No detail',
          loadFailed: 'Failed to load alert detail',
          manualResolve: 'Mark as Resolved',
          manualResolvedSuccess: 'Marked as manually resolved',
          manualResolvedFailed: 'Failed to mark as manually resolved',
          silence: 'Ignore Alert',
          silenceSuccess: 'Alert silenced',
          silenceFailed: 'Failed to silence alert',
          viewRule: 'View Rule',
          viewLogs: 'View Logs',
          firedAt: 'Fired At',
          resolvedAt: 'Resolved At',
          ruleId: 'Rule ID',
          dimensions: 'Dimensions',
          historyTitle: 'History',
          historyHint: 'Recent events with same rule + dimensions',
          historyLoading: 'Loading history...',
          historyEmpty: 'No history'
        },
        table: {
          time: 'Time',
          status: 'Status',
          severity: 'Severity',
          platform: 'Platform',
          ruleId: 'Rule ID',
          title: 'Title',
          duration: 'Duration',
          metric: 'Metric / Threshold',
          dimensions: 'Dimensions',
          email: 'Email Sent',
          emailSent: 'Sent',
          emailIgnored: 'Ignored'
        }
      },
      alertRules: {
        title: 'Alert Rules',
        description: 'Create and manage threshold-based system alerts (email-only)',
        loading: 'Loading...',
        empty: 'No alert rules',
        loadFailed: 'Failed to load alert rules',
        saveFailed: 'Failed to save alert rule',
        saveSuccess: 'Alert rule saved successfully',
        deleteFailed: 'Failed to delete alert rule',
        deleteSuccess: 'Alert rule deleted successfully',
        manage: 'Manage Alert Rules',
        create: 'Create Rule',
        createTitle: 'Create Alert Rule',
        editTitle: 'Edit Alert Rule',
        deleteConfirmTitle: 'Delete this rule?',
        deleteConfirmMessage: 'This will remove the rule and its related events. Continue?',
        metricGroups: {
          system: 'System Metrics',
          group: 'Group-level Metrics (requires group_id)',
          account: 'Account-level Metrics'
        },
        metrics: {
          successRate: 'Success Rate (%)',
          errorRate: 'Error Rate (%)',
          upstreamErrorRate: 'Upstream Error Rate (%)',
          p95: 'P95 Latency (ms)',
          p99: 'P99 Latency (ms)',
          cpu: 'CPU Usage (%)',
          memory: 'Memory Usage (%)',
          queueDepth: 'Concurrency Queue Depth',
          groupAvailableAccounts: 'Group Available Accounts',
          groupAvailableRatio: 'Group Available Ratio (%)',
          groupRateLimitRatio: 'Group Rate Limit Ratio (%)',
          accountRateLimitedCount: 'Rate-limited Accounts',
          accountErrorCount: 'Error Accounts (excluding temporarily unschedulable)',
          accountErrorRatio: 'Error Account Ratio (%)',
          accountTempUnscheduledCount: 'Temporarily Unschedulable Accounts',
          overloadAccountCount: 'Overloaded Accounts'
        },
        metricDescriptions: {
          successRate: 'Percentage of successful requests in the window (0-100).',
          errorRate: 'Percentage of failed requests in the window (0-100).',
          upstreamErrorRate: 'Percentage of upstream failures in the window (0-100).',
          p95: 'P95 request latency within the window (ms).',
          p99: 'P99 request latency within the window (ms).',
          cpu: 'Current instance CPU usage (0-100).',
          memory: 'Current instance memory usage (0-100).',
          queueDepth: 'Concurrency queue depth within the window (queued requests).',
          groupAvailableAccounts: 'Number of available accounts in the selected group (requires group_id).',
          groupAvailableRatio: 'Available account ratio in the selected group (0-100, requires group_id).',
          groupRateLimitRatio: 'Rate-limited account ratio in the selected group (0-100, requires group_id).',
          accountRateLimitedCount: 'Number of rate-limited accounts within the window.',
          accountErrorCount: 'Number of error accounts within the window (excluding temporarily unschedulable).',
          accountErrorRatio: 'Error account ratio within the window (0-100).',
          accountTempUnscheduledCount: 'Number of accounts currently temporarily unschedulable (e.g. proxy/credential failure auto-eviction).',
          overloadAccountCount: 'Number of overloaded accounts within the window.'
        },
        hints: {
          recommended: 'Recommended: operator {operator}, threshold {threshold}{unit}',
          groupRequired: 'This is a group-level metric; selecting a group (group_id) is required.',
          groupOptional: 'Optional: limit the rule to a specific group via group_id.'
        },
        table: {
          name: 'Name',
          metric: 'Metric',
          severity: 'Severity',
          enabled: 'Enabled',
          actions: 'Actions'
        },
        form: {
          name: 'Name',
          description: 'Description',
          metric: 'Metric',
          operator: 'Operator',
          groupId: 'Group (group_id)',
          groupPlaceholder: 'Select a group',
          allGroups: 'All groups',
          threshold: 'Threshold',
          severity: 'Severity',
          window: 'Window (minutes)',
          sustained: 'Sustained (samples)',
          cooldown: 'Cooldown (minutes)',
          enabled: 'Enabled',
          notifyEmail: 'Send email notifications'
        },
        validation: {
          title: 'Please fix the following issues',
          invalid: 'Invalid rule',
          nameRequired: 'Name is required',
          metricRequired: 'Metric is required',
          groupIdRequired: 'group_id is required for group-level metrics',
          operatorRequired: 'Operator is required',
          thresholdRequired: 'Threshold must be a number',
          windowRange: 'Window must be one of: 1, 5, 60 minutes',
          sustainedRange: 'Sustained must be between 1 and 1440 samples',
          cooldownRange: 'Cooldown must be between 0 and 1440 minutes'
        }
      },
      runtime: {
        title: 'Ops Runtime Settings',
        description: 'Stored in database; changes take effect without editing config files.',
        loading: 'Loading...',
        noData: 'No runtime settings available',
        loadFailed: 'Failed to load runtime settings',
        saveSuccess: 'Runtime settings saved',
        saveFailed: 'Failed to save runtime settings',
        alertTitle: 'Alert Evaluator',
        groupAvailabilityTitle: 'Group Availability Monitor',
        evalIntervalSeconds: 'Evaluation Interval (seconds)',
        silencing: {
          title: 'Alert Silencing (Maintenance Mode)',
          enabled: 'Enable silencing',
          globalUntil: 'Silence until (RFC3339)',
          untilHint: 'Leave empty to only toggle silencing without an expiry (not recommended).',
          reason: 'Reason',
          reasonPlaceholder: 'e.g., planned maintenance',
          entries: {
            title: 'Advanced: targeted silencing',
            hint: 'Optional: silence only certain rules or severities. Leave fields empty to match all.',
            add: 'Add Entry',
            empty: 'No targeted entries',
            entryTitle: 'Entry #{n}',
            ruleId: 'Rule ID (optional)',
            ruleIdPlaceholder: 'e.g., 1',
            severities: 'Severities (optional)',
            severitiesPlaceholder: 'e.g., P0,P1 (empty = all)',
            until: 'Until (RFC3339)',
            reason: 'Reason',
            validation: {
              untilRequired: 'Entry until time is required',
              untilFormat: 'Entry until time must be a valid RFC3339 timestamp',
              ruleIdPositive: 'Entry rule_id must be a positive integer',
              severitiesFormat: 'Entry severities must be a comma-separated list of P0..P3'
            }
          },
          validation: {
            timeFormat: 'Silence time must be a valid RFC3339 timestamp'
          }
        },
        lockEnabled: 'Distributed Lock Enabled',
        lockKey: 'Distributed Lock Key',
        lockTTLSeconds: 'Distributed Lock TTL (seconds)',
        showAdvancedDeveloperSettings: 'Show advanced developer settings (Distributed Lock)',
        advancedSettingsSummary: 'Advanced settings (Distributed Lock)',
        evalIntervalHint: 'How often the evaluator runs. Keeping the default is recommended.',
        validation: {
          title: 'Please fix the following issues',
          invalid: 'Invalid settings',
          evalIntervalRange: 'Evaluation interval must be between 1 and 86400 seconds',
          lockKeyRequired: 'Distributed lock key is required when lock is enabled',
          lockKeyPrefix: 'Distributed lock key must start with "{prefix}"',
          lockKeyHint: 'Recommended: start with "{prefix}" to avoid conflicts',
          lockTtlRange: 'Distributed lock TTL must be between 1 and 86400 seconds',
          slaMinPercentRange: 'SLA minimum percentage must be between 0 and 100',
          ttftP99MaxRange: 'TTFT P99 maximum must be a number ≥ 0',
          requestErrorRateMaxRange: 'Request error rate maximum must be between 0 and 100',
          upstreamErrorRateMaxRange: 'Upstream error rate maximum must be between 0 and 100'
        }
      },
      email: {
        title: 'Email Notification',
        description: 'Configure alert/report email notifications (stored in database).',
        loading: 'Loading...',
        noData: 'No email notification config',
        loadFailed: 'Failed to load email notification config',
        saveSuccess: 'Email notification config saved',
        saveFailed: 'Failed to save email notification config',
        alertTitle: 'Alert Emails',
        reportTitle: 'Report Emails',
        recipients: 'Recipients',
        recipientsHint: 'If empty, the system may fallback to the first admin email.',
        minSeverity: 'Min Severity',
        minSeverityAll: 'All severities',
        rateLimitPerHour: 'Rate limit per hour',
        batchWindowSeconds: 'Batch window (seconds)',
        includeResolved: 'Include resolved alerts',
        dailySummary: 'Daily summary',
        weeklySummary: 'Weekly summary',
        errorDigest: 'Error digest',
        errorDigestMinCount: 'Min errors for digest',
        accountHealth: 'Account health',
        accountHealthThreshold: 'Error rate threshold (%)',
        cronPlaceholder: 'Cron expression',
        reportHint: 'Schedules use cron syntax; leave empty to use defaults.',
        validation: {
          title: 'Please fix the following issues',
          invalid: 'Invalid email notification config',
          alertRecipientsRequired: 'Alert emails are enabled but no recipients are configured',
          reportRecipientsRequired: 'Report emails are enabled but no recipients are configured',
          invalidRecipients: 'One or more recipient emails are invalid',
          rateLimitRange: 'Rate limit per hour must be a number ≥ 0',
          batchWindowRange: 'Batch window must be between 0 and 86400 seconds',
          cronRequired: 'A cron expression is required when schedule is enabled',
          cronFormat: 'Cron expression format looks invalid (expected at least 5 parts)',
          digestMinCountRange: 'Min errors for digest must be a number ≥ 0',
          accountHealthThresholdRange: 'Account health threshold must be between 0 and 100'
        }
      },
      settings: {
        title: 'Ops Monitoring Settings',
        loadFailed: 'Failed to load settings',
        saveSuccess: 'Ops monitoring settings saved successfully',
        saveFailed: 'Failed to save settings',
        dataCollection: 'Data Collection',
        evaluationInterval: 'Evaluation Interval (seconds)',
        evaluationIntervalHint: 'Frequency of detection tasks, recommended to keep default',
        alertConfig: 'Alert Configuration',
        enableAlert: 'Enable Alerts',
        alertRecipients: 'Alert Recipient Emails',
        emailPlaceholder: 'Enter email address',
        recipientsHint: 'If empty, the system will use the first admin email as default recipient',
        minSeverity: 'Minimum Severity',
        reportConfig: 'Report Configuration',
        enableReport: 'Enable Reports',
        reportRecipients: 'Report Recipient Emails',
        dailySummary: 'Daily Summary',
        weeklySummary: 'Weekly Summary',
        metricThresholds: 'Metric Thresholds',
        metricThresholdsHint: 'Configure alert thresholds for metrics, values exceeding thresholds will be displayed in red',
        slaMinPercent: 'SLA Minimum Percentage',
        slaMinPercentHint: 'SLA below this value will be displayed in red (default: 99.5%)',
        ttftP99MaxMs: 'TTFT P99 Maximum (ms)',
        ttftP99MaxMsHint: 'TTFT P99 above this value will be displayed in red (default: 500ms)',
        requestErrorRateMaxPercent: 'Request Error Rate Maximum (%)',
        requestErrorRateMaxPercentHint: 'Request error rate above this value will be displayed in red (default: 5%)',
        upstreamErrorRateMaxPercent: 'Upstream Error Rate Maximum (%)',
        upstreamErrorRateMaxPercentHint: 'Upstream error rate above this value will be displayed in red (default: 5%)',
        advancedSettings: 'Advanced Settings',
        dataRetention: 'Data Retention Policy',
        enableCleanup: 'Enable Data Cleanup',
        cleanupSchedule: 'Cleanup Schedule (Cron)',
        cleanupScheduleHint: 'Example: 0 2 * * * means 2 AM daily',
        errorLogRetentionDays: 'Error Log Retention Days',
        minuteMetricsRetentionDays: 'Minute Metrics Retention Days',
        hourlyMetricsRetentionDays: 'Hourly Metrics Retention Days',
        retentionDaysHint: 'Recommended 7-90 days; longer periods consume more storage. Set to 0 to wipe all history on every scheduled cleanup',
        aggregation: 'Pre-aggregation Tasks',
        enableAggregation: 'Enable Pre-aggregation',
        aggregationHint: 'Pre-aggregation improves query performance for long time windows',
        openaiQuotaAutoPause: 'OpenAI Account Quota Auto-pause',
        openaiQuotaAutoPauseHint: 'When an OpenAI account reaches its 5h / 7d usage threshold, the scheduler skips it automatically and resumes once the window rolls over. Per-account thresholds take precedence over this global default.',
        openaiQuotaAutoPauseDefault5h: 'Default 5h usage threshold (%)',
        openaiQuotaAutoPauseDefault7d: 'Default 7d usage threshold (%)',
        openaiQuotaAutoPauseThresholdHint: 'Value 0-100; leave blank or 0 to disable the global default threshold.',
        errorFiltering: 'Error Filtering',
        ignoreCountTokensErrors: 'Ignore count_tokens errors',
        ignoreCountTokensErrorsHint: 'When enabled, errors from count_tokens requests will not be written to the error log.',
        ignoreContextCanceled: 'Ignore client disconnect errors',
        ignoreContextCanceledHint: 'When enabled, client disconnect (context canceled) errors will not be written to the error log.',
        ignoreNoAvailableAccounts: 'Ignore no available accounts errors',
        ignoreNoAvailableAccountsHint: 'When enabled, "No available accounts" errors will not be written to the error log (not recommended; usually a config issue).',
        ignoreInsufficientBalanceErrors: 'Ignore Insufficient Balance Errors',
        ignoreInsufficientBalanceErrorsHint: 'When enabled, insufficient account balance errors will not be written to the error log.',
        autoRefresh: 'Auto Refresh',
        enableAutoRefresh: 'Enable auto refresh',
        enableAutoRefreshHint: 'Automatically refresh dashboard data at a fixed interval.',
        refreshInterval: 'Refresh Interval',
        refreshInterval15s: '15 seconds',
        refreshInterval30s: '30 seconds',
        refreshInterval60s: '60 seconds',
        dashboardCards: 'Dashboard Cards',
        displayAlertEvents: 'Display alert events',
        displayAlertEventsHint: 'Show or hide the recent alert events card on the ops dashboard. Enabled by default.',
        displayOpenAITokenStats: 'Display OpenAI token request stats',
        displayOpenAITokenStatsHint: 'Show or hide the OpenAI token request stats card on the ops dashboard. Hidden by default.',
        autoRefreshCountdown: 'Auto refresh: {seconds}s',
        validation: {
          title: 'Please fix the following issues',
          retentionDaysRange: 'Retention days must be between 0 and 365 (0 = wipe all on every cleanup)',
          slaMinPercentRange: 'SLA minimum percentage must be between 0 and 100',
          ttftP99MaxRange: 'TTFT P99 maximum must be a number ≥ 0',
          requestErrorRateMaxRange: 'Request error rate maximum must be between 0 and 100',
          upstreamErrorRateMaxRange: 'Upstream error rate maximum must be between 0 and 100',
          openaiQuotaAutoPauseRange: 'OpenAI quota auto-pause threshold must be between 0 and 100'
        }
      },
      concurrency: {
        title: 'Concurrency / Queue',
        byPlatform: 'By Platform',
        byGroup: 'By Group',
        byAccount: 'By Account',
        byUser: 'By User',
        showByUserTooltip: 'Switch to user view to see concurrency usage per user',
        switchToUser: 'Switch to user view',
        switchToPlatform: 'Switch to platform view',
        totalRows: '{count} rows',
        disabledHint: 'Realtime monitoring is disabled in settings.',
        empty: 'No data',
        queued: 'Queue {count}',
        rateLimited: 'Rate-limited {count}',
        errorAccounts: 'Errors {count}',
        loadFailed: 'Failed to load concurrency data'
      },
      realtime: {
        title: 'Realtime',
        connected: 'Realtime connected',
        connecting: 'Realtime connecting',
        reconnecting: 'Realtime reconnecting',
        offline: 'Realtime offline',
        closed: 'Realtime closed',
        reconnectIn: 'retry in {seconds}s'
      },
      queryMode: {
        auto: 'Auto',
        raw: 'Raw',
        preagg: 'Preagg'
      },
      accountAvailability: {
        available: 'Available',
        unavailable: 'Unavailable',
        accountError: 'Error'
      },
      tooltips: {
        totalRequests: 'Total number of requests (including both successful and failed requests) in the selected time window.',
        throughputTrend: 'Requests/QPS + Tokens/TPS in the selected window.',
        switchRateTrend: 'Trend of account switches / total requests over the last 5 hours (avg switches).',
        latencyHistogram: 'Request duration distribution (ms) for successful requests.',
        errorTrend: 'Error counts over time (SLA scope excludes business limits; upstream excludes 429/529).',
        errorDistribution: 'Error distribution by status code (SLA scope, excluding business limits).',
        goroutines:
          'Number of Go runtime goroutines (lightweight threads). There is no absolute "safe" number—use your historical baseline. Heuristic: <2k is common; 2k–8k watch; >8k plus rising queue/latency often suggests blocking/leaks.',
        cpu: 'CPU usage percentage, showing system processor load.',
        memory: 'Memory usage, including used and total available memory.',
        db: 'Database connection pool status, including active, idle, and waiting connections.',
        redis: 'Redis connection pool status, showing active and idle connections.',
        jobs: 'Background job execution status, including last run time, success time, and error information.',
        qps: 'Queries Per Second (QPS) and Tokens Per Second (TPS), real-time system throughput.',
        tokens: 'Total number of tokens processed in the current time window.',
        sla: 'Service Level Agreement success rate, excluding business limits (e.g., insufficient balance, quota exceeded).',
        errors: 'Error statistics, including total errors, error rate, and upstream error rate.',
        upstreamErrors: 'Upstream error statistics, excluding rate limit errors (429/529).',
        latency: 'Request duration statistics, including p50, p90, p95, p99 percentiles.',
        ttft: 'Time To First Token, measuring the speed of first token return in streaming responses.',
        health: 'System health score (0-100), considering SLA, error rate, and resource usage.'
      },
      charts: {
        emptyRequest: 'No requests in this window.',
        emptyError: 'No errors in this window.',
        resetZoom: 'Reset',
        resetZoomHint: 'Reset zoom (if enabled)',
        downloadChart: 'Download',
        downloadChartHint: 'Download chart as image'
      }
    },

    // Settings
}
