/** Словарь локали «en». Плоская правка: ключи обеих локалей обязаны совпадать. */
export const en = {
  appName: 'TeleWave',
  nav: {
    dashboard: 'On Air',
    admin: 'Admin',
    settings: 'Settings',
    login: 'Log in',
    register: 'Sign up',
    logout: 'Log out',
  },
  theme: { light: 'Light', dark: 'Dark', system: 'System' },
  lang: { ru: 'RU', en: 'EN' },
  common: {
    save: 'Save',
    cancel: 'Cancel',
    retry: 'Retry',
    close: 'Close',
    delete: 'Delete',
    create: 'Create',
    loading: 'Loading…',
    error: 'Something went wrong',
    search: 'Search',
    actions: 'Actions',
    prevPage: 'Previous page',
    nextPage: 'Next page',
    yes: 'Yes',
    no: 'No',
  },
  home: {
    title: 'TELEWAVE',
    subtitle: 'BROADCAST CHANNEL GRID',
    tagline: 'Your channels. Your broadcast. Anytime.',
    cta: 'Go on air',
    ctaRegister: 'Create account',
  },
  auth: {
    userName: 'Username',
    password: 'Password',
    loginTitle: 'Sign in',
    loginSubtitle: 'Enter your credentials to access the channel grid',
    registerTitle: 'New viewer',
    registerSubtitle: 'Create an account to set up your channel grid',
    submitLogin: 'Log in',
    submitRegister: 'Sign up',
    noAccount: "Don't have an account?",
    haveAccount: 'Already have an account?',
    registrationClosed: 'Registration is closed',
    registrationClosedHint:
      'Public registration is disabled. An administrator can create an account for you.',
    invalidCredentials: 'Invalid username or password',
    userNameTaken: 'This username is already taken',
    blocked: 'Account blocked by an administrator',
    genericError: 'Could not sign in. Please try again',
  },
  air: {
    now: 'Now',
    next: 'Up next',
    ad: 'Ad',
    bumper: 'Bumper',
    fallback: 'Emergency filler',
    signOff: 'Sign-off',
    episode: 'Episode',
    collectionPart: 'part {{part}} of {{total}}',
    volume: 'Volume',
    live: 'Live',
    noChannels: 'No channels available yet. Check back later.',
    offline: 'This channel is off the air',
    offlineHint: 'No schedule or content yet. Check back later.',
    retry: 'Retry',
    numbersHint: '↑ / ↓ — switch channels by number',
    iptv: 'IPTV playlist',
    iptvHint:
      'An M3U with every channel and the programme guide — for VLC, TiviMate and the like. Access to the air is baked into the file itself: do not share it.',
    iptvDone: 'Playlist downloaded. The file grants access to the air — do not pass it on.',
    iptvFailed: 'Could not build the playlist',
  },
  settings: {
    title: 'Account settings',
    changeUserName: 'Change username',
    newUserName: 'New username',
    changePassword: 'Change password',
    currentPassword: 'Current password',
    newPassword: 'New password',
    dangerZone: 'Danger zone',
    deleteAccount: 'Delete account',
    deleteAccountConfirm: 'The account and all its data will be permanently deleted. Continue?',
    saved: 'Saved',
  },
  admin: {
    groups: {
      title: 'Groups',
      createTitle: 'Create a group',
      hint: 'A group is what may go on air. Grid slots reference it; the strategy picks an element from it.',
      name: 'Name',
      description: 'Description',
      items: 'Items',
      units: 'Units',
      duration: 'Runtime',
      hoursShort: 'h',
      minutesShort: 'min',
      hasFilter: 'has rule',
      composition: 'Composition',
      empty: 'Group is empty',
      orderHint: 'Drag to set the order — sequential strategies follow it.',
      showAdvanced: 'Advanced',
      hideAdvanced: 'Hide',
      find: 'Find matches',
      addFound: 'Add found',
      found: 'Found: {{total}}, new: {{fresh}}',
      added: 'Items added: {{count}}',
      alreadyIn: 'already in group',
      mode: {
        switchConfirm:
          'Switch the mode? The item list will be rebuilt: in a static group it is the composition itself, in a dynamic one — only corrections to the rule.',
        label: 'Composition',
        Static: 'Explicit list',
        Dynamic: 'By rule',
        StaticHint: 'Items are added by hand; the rule only helps to find them.',
        DynamicHint:
          'Composition is computed by the rule on every read — new library items go on air by themselves.',
      },
      pinned: 'pinned',
      byRule: 'by rule',
      excluded: 'Excluded',
      excludeHint: 'Exclude from the composition — the rule will stop adding it back',
      restore: 'Restore',
      dynamicOrderHint:
        'Order: pinned items first (drag to arrange), then rule matches alphabetically.',
      previewComposition: 'With this rule the composition would be: {{count}}',
      pendingFound: 'New matches for this rule: {{count}} —',
      pendingAdd: 'Add all ({{count}})',
      elementKinds: { Show: 'Show', Collection: 'Collection' },
      suggestions: {
        title: 'Suggestions',
        hint: 'Built from the current library. The button creates a group with these items and saves the rule — later additions are then one click away.',
        stats: '{{shows}} shows · {{units}} units',
        exists: 'already exists',
        created: 'Group created',
        allCreated: 'Every suggestion has been created already.',
        showExisting: 'Show already created ({{count}})',
        hideExisting: 'Hide already created',
        kinds: {
          Genre: 'genre',
          ShowKind: 'kind',
          Audience: 'rating',
          BigSeries: 'big series',
        },
      },
      filter: {
        title: 'Selection rule',
        hint: 'In an explicit list the rule only finds candidates; in a rule-based group it is the composition.',
        elementKinds: 'What to search',
        showKinds: 'Show type',
        showKindsHint:
          'Unchecked means films and series. Clips live in their own library and join the selection only when checked explicitly.',
        genres: 'Genres',
        genresHint: 'Any of the checked ones.',
        maxAudience: 'No stricter than',
        minAudience: 'No softer than',
        minAudienceHint:
          'For late-night slots. Unlike the upper bound, unrated shows are excluded — otherwise unrated cartoons would slip into the adult group.',
        audienceHint:
          'Ratings are ordered by strictness: G → PG → PG-13 → R → NC-17. Unrated shows stay in the selection.',
        year: 'Year',
        unitMinutes: 'Unit runtime, min',
        unitMinutesHint:
          'Average episode or film length. Items without ready assets are not filtered out.',
        from: 'from',
        to: 'to',
        any: 'any',
      },
    },
    collections: {
      posters: 'Fill posters',
      postersHint:
        'Takes the first part’s cover for collections that have no poster yet. A hand-picked one is left alone.',
      postersDone: 'Posters filled: {{count}}',
      title: 'Collections',
      createTitle: 'Create a collection',
      hint: 'A franchise is an ordered set of films played as a single unit.',
      name: 'Name',
      description: 'Description',
      parts: 'Parts',
      units: 'Units',
      addShow: 'Add show',
      pickShow: 'Pick a show',
      empty: 'Collection is empty',
      orderHint: 'Drag to set the order of the parts — that is the order they air in.',
      suggestions: {
        title: 'Franchise suggestions',
        hint: 'Built from movies not in any collection yet: what to assemble into a new franchise and what to add to an assembled one. Check the parts — the name-based guess sometimes misses.',
        parts: '{{count}} parts',
        exists: 'already exists',
        additionBadge: 'addition',
        add: 'Add',
        added: 'Added to the collection: {{count}}',
        created: 'Collection created',
        allCreated: 'Every suggestion has been created already.',
        showExisting: 'Show already created ({{count}})',
        hideExisting: 'Hide already created',
        sources: { Metadata: 'from metadata', NameGuess: 'by names' },
      },
    },
    interstitials: {
      title: 'Clips',
      hint: 'Ads, promos and jingles. Drag clips into the block builder or a group on the right — a block is saved as a collection and airs as a whole.',
      upload: 'Upload clips',
      name: 'Name',
      duration: 'Duration',
      empty: 'No clips yet',
      noAsset: 'No file',
      blocks: 'Blocks',
      noBlocks: 'No blocks yet',
      clipsCount: '{{count}} clips',
      blockBuilder: 'Block builder',
      blockName: 'Block name',
      blockTotal: 'Block duration',
      dropHint: 'Drop clips here',
      groups: 'Clip groups',
      pickGroup: 'Pick a group',
      pickGroupFirst: 'Pick a group first',
      dropToGroup: 'Drop a clip or a block here',
      openGroup: 'Open group',
      newGroupName: 'Group name',
      createGroupTitle: 'Create a clip group',
    },
    genres: {
      title: 'Genres',
      hint: 'Genre reference: content groups are built from it, provider metadata is mapped into it.',
      name: 'Name',
      slug: 'Key',
      slugHint: 'Latin letters, no spaces — the genre is matched by it when the reference updates.',
      aliases: 'Spellings',
      aliasesHint: 'Comma-separated. Maps provider genres onto yours: tmdb:28, action, боевик.',
      order: 'Order',
      usage: 'Shows',
      system: 'System',
      create: 'New genre',
      edit: 'Edit genre',
    },
    roles: {
      title: 'Roles',
      name: 'Name',
      system: 'System',
      create: 'New role',
      rename: 'Rename',
    },
    users: {
      title: 'Users',
      userName: 'Username',
      role: 'Role',
      status: 'Status',
      createdAt: 'Joined',
      blocked: 'Blocked',
      active: 'Active',
      block: 'Block',
      unblock: 'Unblock',
      resetPassword: 'Password',
      resetPasswordFor: 'Reset password: {{name}}',
      newPassword: 'New password',
      passwordReset: 'Password changed',
      filterAll: 'All roles',
      createTitle: 'Create user',
      password: 'Password',
      passwordHint: 'At least 8 characters, including a digit and an uppercase letter.',
      create: 'Create',
      created: 'User created',
    },
    movies: {
      title: 'Movie import',
      hint: 'The file name is parsed into a title and a year, and the movie is looked up in the metadata source. Every file becomes its own show; fix the rows where the match is not exact.',
      sources: { manual: 'From manual folder', disk: 'From my disk' },
      pickFiles: 'Pick files',
      scan: 'Parse ({{count}})',
      scanning: 'Searching the source…',
      nothingYet: 'Pick a source and press "Parse".',
      noProvider: 'No metadata source configured — there is nothing to search with.',
      file: 'File',
      parsed: 'Title and year',
      candidate: 'Candidate',
      toggleAll: 'Select all / clear all',
      year: 'Year',
      research: 'Search again',
      empty: 'nothing found',
      noCandidate: 'no metadata',
      import: 'Create ({{count}})',
      imported: 'Movies created: {{created}}, with metadata: {{enriched}}',
      uploadStarted: 'Files are uploading — movies appear as they finish',
      collectionsHint:
        'Franchises turn into collections after the import — the suggestions wait on the Collections tab.',
      statuses: {
        Confident: 'exact match',
        Uncertain: 'check this',
        NotFound: 'not found — type the title',
        AlreadyInLibrary: 'already in the library',
      },
    },
    media: {
      title: 'Media',
      upload: 'Upload',
      preview: 'Preview',
      retry: 'Retry',
      retryAll: 'Retry failed',
      retryQueued: 'Requeued: {{count}}',
      manualButton: 'From manual folder',
      importButton: 'Import',
      importTitle: 'Media import',
      importHint:
        'Three ways to fill the library: episodes from the manual folder into a show, movies in bulk, and uploading picked files into a show.',
      importTabs: {
        movies: 'Movies',
        manual: 'Episodes from manual',
        toShow: 'Picked files into a show',
      },
      moviesButton: 'Movies',
      manualTitle: 'Manual pick from the manual folder',
      manualHint:
        'Files in manual/ are not picked up by the scanner — select the ones you need and choose a show. Imported files leave the folder, just like from inbox.',
      manualSelectAll: 'Select all',
      manualSelected: 'Selected: {{count}}',
      manualEmpty: 'The manual folder is empty',
      regexPickHint: 'Click a number in the file name — a rule for all files is built from it:',
      regexPickTitle: 'This is the episode number',
      regexPresets: 'Ready-made:',
      regexPresetNames: {
        seriesWord: 'Серия N',
        episodeWord: 'Эпизод N',
        seasonEpisode: 'SxxEyy',
        productionCode: '2ACV01',
        afterDash: 'after a dash',
        firstNumber: 'first number',
      },
      regexClear: 'clear',
      manualAlready: 'already in the library',
      manualRoot: 'manual/ root',
      manualRecognized: 'Recognized: {{count}} of {{total}}',
      manualCleanupHint:
        'Files leave the folder; siblings (subtitles, nfo) and the emptied folder are removed.',
      manualTruncated: 'Showing the first 500 files — there are more in the folder.',
      manualShow: 'Show',
      manualDetected: 'Detected from the release name — check it and change if wrong.',
      manualPickShow: 'Pick a show',
      manualImport: 'Import into show',
      manualImported: 'Files imported: {{count}}',
      uploadToShow: 'Upload to show',
      toShowTitle: 'Upload and add to show',
      toShowPick: 'Pick files',
      toShowEmpty: 'No files picked',
      toShowPicked: 'Files picked: {{count}}',
      autoDetectHint:
        'Each file is linked to the show whose original (or display) name appears in the release name, e.g. “The.Simpsons.S33E01…” → The Simpsons.',
      toShowLibrary: 'To library',
      toShowSeason: 'Season (manual)',
      toShowAuto: 'auto',
      toShowRegex: 'Episode regex',
      toShowRegexInvalid: 'invalid regex',
      toShowHint: String.raw`Season and regex are optional: numbers are usually detected automatically (see below). Regex: 1 group = episode, 2 groups = season and episode. Example: ^(\d+) for “01. Title.mkv”.`,
      toShowPreview: 'What we detect',
      toShowMatched: 'show detected for {{matched}} of {{total}}',
      applyToAll: 'Set for all…',
      toShowUnknown: '—',
      toShowConfirm: 'Upload and add',
      uploadedCount: 'Uploaded files: {{count}}',
      uploadingCount: 'Uploading {{done}}/{{total}}',
      cancelAll: 'Cancel all uploads',
      skippedDuplicates: 'Skipped duplicates: {{count}}',
      queueDrained: 'Processing finished — the queue is empty',
      filterActive: 'Active',
      filterAll: 'All',
      name: 'File',
      status: 'Status',
      duration: 'Duration',
      resolution: 'Resolution',
      processingTime: 'Processing time',
      empty: 'No uploaded files yet',
      statuses: {
        Pending: 'Queued',
        Processing: 'Processing',
        Ready: 'Ready',
        Failed: 'Failed',
      },
      stats: {
        queued: 'Currently queued',
        queuedShort: 'Queued',
        processing: 'Currently processing',
        processingShort: 'Processing',
        average: 'Average processing time (recent)',
        averageShort: 'Avg time',
        eta: 'Estimated time until the queue drains: work left at the average rate, divided by the number of parallel transcodes',
        etaShort: 'Left',
        etaSoon: 'under a minute',
        hoursShort: 'h',
        minutesShort: 'min',
      },
    },
    gallery: {
      title: 'Gallery',
      upload: 'Upload',
      empty: 'No images in this category yet',
      pickHint: 'Pick an image or upload a new one',
      browseHint: 'All app images by category',
      sort: {
        newest: 'Newest first',
        oldest: 'Oldest first',
        nameAsc: 'Name: A–Z',
        nameDesc: 'Name: Z–A',
      },
      categories: {
        Library: 'Library',
        ShowPoster: 'Show posters',
        EpisodeStill: 'Episode stills',
        BumperBackground: 'Bumper backgrounds',
      },
    },
    shows: {
      title: 'Shows',
      createTitle: 'Create a show',
      name: 'Name',
      originalName: 'Original name (eng)',
      kind: 'Kind',
      kinds: { Series: 'Series', Single: 'Movie', Interstitial: 'Clip' },
      pickerPlaceholder: 'Pick a show',
      pickerSearch: 'Search by name…',
      pickerEmpty: 'Nothing found',
      pickerCreate: 'Create series “{{name}}”',
      pickerCreateSingleHint: 'Create as a movie',
      pickerCreated: 'Show created',
      audience: 'Rating',
      audienceUnset: 'Not rated',
      audiences: {
        G: 'G — general audiences',
        PG: 'PG — parental guidance',
        'PG-13': 'PG-13 — over 13',
        R: 'R — under 17 with adult',
        'NC-17': 'NC-17 — adults only',
      },
      seasons: 'Seasons',
      loadedSeasons: 'Loaded seasons',
      genre: 'Genre',
      allGenres: 'All genres',
      allKinds: 'All kinds',
      deleteTitle: 'Delete the show?',
      deleteHint: '“{{name}}” will be removed from the library. This cannot be undone.',
      deleteWithMedia: 'Delete its media too: {{count}} file(s)',
      deleteWithMediaHint:
        'Otherwise the files stay in the media list with no owner and keep taking space.',
      deleteWithSchedule: 'Cut it from the upcoming air too',
      deleteWithScheduleHint:
        'Without this the deletion is refused while the show sits in the feed. Viewers see the filler where it was until the tail is rebuilt.',
      otherGenres: 'Other genres',
      bulk: {
        selected: 'Selected: {{count}}',
        selectPage: 'Select all on this page',
        noGenre: 'Keep genres',
        keepAudience: 'Keep rating',
        apply: 'Apply',
        tagged: 'Shows updated: {{count}}',
        clear: 'Clear selection',
        enrich: 'Metadata from {{provider}}',
        enrichHint:
          'Search by name and apply — only for shows with no source linked. Ambiguous matches are skipped.',
        enriching: 'Searching…',
        enriched: 'Metadata applied: {{count}}',
        moreSkipped: 'Skipped as well: {{count}}',
        toCollection: 'To collection…',
        toCollectionHint:
          'The selected shows go into a franchise. Parts are ordered by release year; drag to rearrange them in the collection card.',
        newCollection: 'New collection',
        addToCollection: 'Add ({{count}})',
        addedToCollection: '“{{name}}” updated: {{count}}',
      },
      genresEmpty: 'No genres set',
      genresEdit: 'Genres',
      genresHint:
        'Pick the genres of the show. The primary one is listed; all of them are used for selection.',
      genrePrimary: 'primary',
      inGroups: 'In groups',
      inChannels: 'Scheduled on',
      inCollections: 'Part of collections',
      episodes: 'Episodes',
      episode: 'Episode',
      noEpisodes: 'No episodes yet',
      addMedia: 'Add media',
      addMediaHint: 'Ready files not yet in this show. The selected ones are added as episodes.',
      filterAssets: 'Filter by name, e.g. Family.Guy.S16',
      selectAll: 'Select all',
      deselectAll: 'Clear',
      addSelected: 'Add selected',
      noMatches: 'No matching files',
      addedCount: 'Episodes added: {{count}}',
      candidatesTruncated:
        'Not all files are shown (too many ready assets) — narrow the filter to see the rest.',
    },
    channels: {
      number: 'Number',
      numberPlaceholder: 'not set',
      utcOffset: 'Time zone, h',
      utcOffsetHint:
        'Whole hours: 3 is Moscow, 0 is UTC, −5 is New York. The whole grid and the schedule are expressed in this time.',
      dayStart: 'Broadcast day starts',
      dayStartHint: 'The night block before this time belongs to the previous day.',
      disabled: 'disabled',
      layers: 'Layers',
      layersHint: 'Higher priority wins. The background layer sits below all and fills gaps.',
      background: 'background',
      newLayerName: 'New layer',
      addSlotHere: 'Add slot',
      newSlot: 'New slot',
      /** Grid auto-build by profile: plan preview and creation. */
      transfer: {
        action: 'Import / export',
        title: 'Grid configuration exchange',
        hint: 'The file references groups and junctions by name, so it moves between channels and installations. The AI request is not sent anywhere — you copy it into your own model and bring the answer back to the import tab.',
        tabs: { export: 'Export', import: 'Import', ai: 'AI request' },
        exportHint:
          'Exports layers, slots, rules and references to groups and junctions. Works both as a backup before an experiment and as a sample for a model.',
        exportAction: 'Download file',
        exported: 'File exported',
        importHint:
          'Load a file or paste JSON — a model answer, for example. The file may bring missing groups and collections with it; shows are never created — those come from media uploads. Unknown references do not break the import: such slots are skipped and listed below.',
        pickFile: 'Pick a file',
        replace: 'Remove existing slots',
        pastePlaceholder: 'Paste the grid configuration JSON',
        importAction: 'Import',
        imported: 'Slots created: {{slots}}, skipped: {{skipped}}',
        importedLibrary: 'Groups created: {{groups}}, collections: {{collections}}',
        badJson: 'That does not look like JSON — check that the whole answer was copied.',
        warnings: 'What could not be resolved',
        aiHint:
          'We build the request: channel settings, your groups and library, your references and notes, plus the answer schema. The model may define the groups it needs — the import creates them.',
        references: 'Reference channels',
        referencesPlaceholder: 'Cartoon Network, Paramount Comedy',
        referencesHint:
          'Comma-separated. The model matches their rhythm — block length, prime, night.',
        notes: 'Notes',
        notesPlaceholder:
          'For example: kids in the morning, films in the evening, adult block at night',
        buildPrompt: 'Build the request',
        copyPrompt: 'Copy',
        copied: 'Request copied',
        aiNext: 'Send this to your model and paste the JSON you get back on the "Import" tab.',
      },
      generate: {
        action: 'Build grid',
        title: 'Grid auto-build',
        hint: 'A profile sets the rhythm of the day: block length, what airs in prime time and what fills the night. Groups are picked from the existing ones by rating, content type and how many units they hold.',
        modes: {
          FillGaps: 'Fill gaps',
          Rebuild: 'Rebuild the week',
        },
        modeHints: {
          FillGaps: 'Existing slots are left alone — only uncovered time is filled.',
          Rebuild:
            'All template slots are removed; the weekend is built as a separate layer on top.',
        },
        summary: 'Slots to create: {{slots}} — that is {{percent}}% of the free week.',
        willRemove: 'Slots to remove: {{count}}.',
        fallback: 'The fallback group will be "{{name}}" — it covers pauses between slots.',
        nothing: 'Nothing to create: there is no free time in the grid.',
        create: 'Build',
        done: 'Created {{created}} slots, removed {{removed}}.',
      },
      editSlot: 'Slot',
      slotTitle: 'Block title',
      slotStart: 'Start',
      slotDuration: 'Budget, min',
      weekday: 'Weekday',
      everyDay: 'every day',
      daypart: 'Daypart',
      slotKind: 'Slot type',
      group: 'Group',
      pickGroup: 'Pick a group',
      strategy: 'Strategy',
      cooldownDays: 'Cooldown, days',
      cooldownHint: 'Skip what already aired within this period.',
      blockMode: 'Block',
      blockValue: 'Value',
      overflow: 'If it does not fit',
      overflowHint: 'What to do with an element that exceeds the slot budget.',
      repeatDaysAgo: 'Days ago',
      repeatTime: 'Time',
      repeatDuration: 'Duration, min',
      anchor: 'Anchor',
      anchorHint:
        'An anchor keeps the start hard: nothing that would cross it is started. Snapping is soft — it shifts the start to a round time if that fits the allowance.',
      maxDrift: 'Allowance, min',
      snap: 'Snap',
      snapOff: 'off',
      resizeSlot: 'Drag the edge to change duration',
      copyDay: 'Copy day',
      copyDayFrom: 'Copy {{day}} to:',
      copy: 'Copy',
      layerVisible: 'Show layer',
      layerName: 'Layer name',
      layerApplicability: 'When it applies',
      applicabilityHint:
        'Sections are OR-ed: the layer applies when the date matches at least one condition. Nothing filled in — it always applies.',
      applicabilityWeekdays: 'Weekdays',
      applicabilityDateRanges: 'Date ranges',
      applicabilityAnnual: 'Yearly (month / day)',
      applicabilityDates: 'Specific dates',
      applicabilityNone: 'not set',
      showForDate: 'Grid for date',
      allDates: 'All layers',
      tabs: {
        grid: 'Grid',
        rules: 'Rules',
        junctions: 'Junctions',
        viewer: 'Viewer',
        settings: 'Settings',
        air: 'On air',
      },
      noTemplate: 'The channel grid failed to load',
      createTemplate: 'Create the grid',
      createTemplateHint:
        'An empty grid with a background layer appears — then add layers and slots.',
      rules: 'Candidate rules',
      rulesHint:
        'Hard filters: they cut out what is not allowed before the draw. Like grid edits, they do not move the air — apply to take effect.',
      audienceWindows: 'Family hours',
      noAudienceWindows: 'No windows — the age is not limited.',
      audienceWindowsHint:
        'Inside a window only content no stricter than the chosen category airs. A window may cross midnight. Content with no category is never dropped.',
      from: 'From',
      to: 'To',
      maxAudience: 'No stricter than',
      repeatLimit: 'Repeat cap',
      repeatWindowDays: 'Window, days',
      repeatMax: 'At most, times',
      repeatLimitHint:
        'Counted against the already recorded tape. If every candidate hits the cap the slot is still filled: empty air is worse than an early repeat.',
      preview: 'Preview',
      previewHide: 'Hide preview',
      previewHint: 'A run against the current rules: nothing is written, slot cursors do not move.',
      previewDays_one: '{{count}} day',
      previewDays_other: '{{count}} days',
      previewTabs: { programme: 'Programme', tape: 'Tape', problems: 'Problems' },
      noProblems: 'No problems',
      andMore: 'and {{count}} more',
      heatmap: 'Repeats: show × day',
      heatmapTotal: 'total',
      issues: 'Checks: {{errors}} errors, {{warnings}} warnings',
      goToSlot: 'to slot',
      issueKinds: {
        GroupEmpty: 'Empty group',
        GroupTooSmall: 'Too little content',
        GridGap: 'Gap in the grid',
        SlotOverlap: 'Slots overlap',
        CooldownUnreachable: 'Unreachable cooldown',
        AudienceConflict: 'Age conflict',
        GroupMissing: 'No group selected',
      },
      viewer: 'How viewers see it',
      viewerHint:
        'Overlays are drawn on the client on top of the picture — the video is not re-encoded. Everything is off by default.',
      logo: 'Logo',
      noLogo: 'none',
      pickLogo: 'Pick a logo',
      logoCorner: 'Corner',
      logoOpacity: 'Opacity',
      corners: {
        TopLeft: 'Top left',
        TopRight: 'Top right',
        BottomLeft: 'Bottom left',
        BottomRight: 'Bottom right',
      },
      showClock: 'Show a clock',
      analogFilter: 'Analog filter',
      analogFilterHint: 'Strength 0..1. Zero is off; it is very easy to overdo.',
      whyHere: 'Why is this here',
      priority: 'priority',
      traceLayer: 'Layer',
      traceSlot: 'Slot',
      traceGroup: 'Group',
      traceCollection: 'Collection',
      traceStrategy: 'Strategy',
      traceJunction: 'Breaks',
      traceDrift: 'drift {{minutes}} min',
      traceSnapped: 'start snapped',
      traceCooldown: 'cooldown {{days}} d.',
      traceCandidates: 'candidates after cooldown: {{count}}',
      diffSummary: 'Affects {{total}} entries, {{changed}} will change',
      diffSoon: 'Entries changing within 24 hours: {{count}}',
      diffNoChanges: 'The air will not change',
      copyTemplate: 'Copy a grid from a channel',
      pickSourceChannel: 'Pick the source channel',
      copyHere: 'Copy here',
      copyTemplateHint:
        'Layers, slots, junctions and rules of the chosen channel replace this channel grid. Groups are shared and not copied.',
      copyTemplateConfirm:
        'This channel grid will be replaced with the chosen channel grid. Continue?',
      templateCopied: 'Copied: {{layers}} layers, {{slots}} slots',
      copyDroppedBumpers: 'Breaks left without a bumper block: {{count}} — set them up by hand',
      // Not «Reset»: that is already the revert-to-aired action (the restore key).
      reset: 'Clear grid',
      resetConfirm:
        'The whole grid — every layer and slot — will be removed, and the future air built from it deleted. The past and the currently playing entry stay. Continue?',
      resetDone: 'Reset: {{layers}} layers, {{slots}} slots, {{entries}} air entries',
      resetHint:
        'While the channel is on, the tape rebuilds itself from the empty grid — with the fallback group. To keep the air empty, clear it in the rules or turn the channel off.',
      fallbackGroup: 'Fallback group',
      fallbackGroupNone: 'None — channel filler only',
      fallbackGroupHint:
        'What fills a pause when even the background layer is empty. An empty grid plays it for the whole air. Set by grid auto-build unless you pick your own.',
      postChecks: 'Post-checks',
      breakLimit: 'Breaks per hour cap, min',
      genreShare: 'Genre share per day cap, %',
      fallbackShare: 'Background share cap, %',
      postChecksHint:
        'Post-checks run against the finished tape and only warn — nothing is replanned.',
      previewKinds: {
        Program: 'Programme',
        Fallback: 'Background',
        SignOff: 'Sign-off',
        Ad: 'Ad',
        Promo: 'Promo',
        Bumper: 'Bumper',
      },
      previewLoad: 'Breaks per hour, peak — {{peak}} min',
      junctions: 'Junctions',
      junctionsHint:
        'What plays between programmes: ads, promos, bumpers. A slot may pick its own junction, otherwise the default one is used.',
      defaultJunction: 'Default junction',
      noJunction: 'no junction',
      junctionBetween: 'Junction inside the slot',
      junctionAfter: 'Junction after the slot',
      junctionDefault: 'default',
      junctionsUsed: 'Used by this channel',
      junctionsNoneUsed: 'The channel references no junction — nothing plays between programmes.',
      openJunctionEditor: 'Junction editor',
      pendingChanges: 'Rules changed — the air still follows the old ones.',
      restore: 'Discard changes',
      restoreConfirm:
        'Roll the grid back to what is on air? Everything changed since the last apply will be lost.',
      restored: 'The grid is back to the on-air state: {{count}} slots.',
      restoreDropped:
        'References not restored: {{count}} — the group or junction was deleted after the apply.',
      apply: 'Apply',
      applied: 'Air rebuilt, entries: {{count}}',
      applyReport: 'Apply report',
      applyReportWarnings:
        'The planner could not honour every rule — {{count}} warnings. The air is built, but these spots are worth a look.',
      weekdays: {
        0: 'Sun',
        1: 'Mon',
        2: 'Tue',
        3: 'Wed',
        4: 'Thu',
        5: 'Fri',
        6: 'Sat',
      },
      dayparts: { Morning: 'Morning', Day: 'Day', Prime: 'Prime', Night: 'Night' },
      slotKinds: { Content: 'Content', Repeat: 'Repeat', SignOff: 'Sign-off' },
      blockModes: { Count: 'Units', Duration: 'Minutes', FillSlot: 'Whole slot' },
      overflows: {
        ContinueNext: 'Continue next time',
        ExtendSlot: 'Extend the slot',
        SkipIfNotFits: 'Do not start',
      },
      strategies: {
        Sequential: 'In order',
        RandomWithCooldown: 'Random with cooldown',
        Fixed: 'Fixed element',
      },
      warnings: {
        SlotEmpty: 'Slot produced no content',
        DriftExceeded: 'Start drifted past the allowance',
        CooldownExhausted: 'Cooldown ruled out every candidate',
        RepeatSourceEmpty: 'Nothing to repeat',
        FallbackEmpty: 'Nothing to fill pauses with',
        CandidatesFiltered: 'The age cap ruled out every candidate',
        BreakLimitExceeded: 'Breaks in an hour exceed the cap',
        GenreShareExceeded: 'Genre share above the norm',
        FallbackShareExceeded: 'Emergency filler share above the norm',
      },

      title: 'Channels',
      createTitle: 'Create a channel',
      name: 'Name',
      slug: 'Slug',
      state: 'State',
      enabled: 'On air',
      enabledLabel: 'Channel on air',
      settings: 'Settings',
      filler: 'Filler',
      noFiller: 'No filler',
      noSchedule: 'Schedule not built yet',
      airToday: 'Today',
      airCount: 'Entries for the day: {{count}}',
      debugExport: 'Debug export',
      debugExportHint:
        'An archive with a snapshot of the channel: grid, groups, slot cursors, tape and a dry run — to work out why the schedule came out the way it did.',
      airHidePast: 'Hide past entries',
      airHideBreaks: 'Hide breaks',
    },
    junctions: {
      title: 'Junctions',
      hint: 'What plays between programmes: ads, promos, bumpers. A junction is shared across channels — a channel only picks which one a slot uses.',
      newName: 'New junction',
      empty0: 'No junctions yet.',
      empty: 'empty',
      from: 'end',
      to: 'start',
      fork: 'fork',
      addElement: '+ break',
      maxTotal: 'Cap, s',
      usedInChannels: 'in channels: {{count}}',
      cannotDeleteUsed: 'The junction is used by channels — drop the references first.',
      splitOut: 'Take out of the fork',
      mergeIntoFork: 'Merge with the previous one into a fork',
      element: 'Break',
      kind: 'Type',
      kinds: {
        Ad: 'Ad',
        Promo: 'Promo',
        Bumper: 'Bumper',
        Filler: 'Filler',
      },
      group: 'Group',
      pickGroup: 'pick a group',
      bumperTemplate: 'Bumper block',
      pickBumper: 'pick a block',
      bumperVariant: 'Text variant',
      bumperVariantAuto: 'by trigger and weights',
      bumperVariantHint:
        'Keep "by trigger and weights" so show changes and episode breaks get different texts.',
      amountMode: 'Measured in',
      amountModes: { Count: 'Units', Duration: 'Minutes' },
      count: 'How many units',
      minutes: 'How many minutes',
      minutesShort: ' min',
      amountHint:
        'For a mixed group (spots and ready-made blocks) count in minutes: one unit there is either a spot or a whole block.',
      required: 'Required',
      requiredHint:
        'Required only decides what gets dropped when time runs short. It does not affect the order — that is the position in the chain.',
      choiceWeight: 'Weight in the fork',
      choiceWeightHint: 'The higher, the more often this break plays (0 — never picked).',
      conditions: 'Conditions',
      onlyOnChange: 'Only on show change',
      chance: 'Chance, %',
      chanceHint:
        'The interval is per break. A fork rolls once for all its options: the picked variant rolls, and its chance is the chance of the whole fork. The roll comes from the generation seed, so rebuilds do not reshuffle breaks.',
      minInterval: 'No more often than once per, min',
      dayparts: 'Dayparts',
      daypartsHint: 'Nothing selected — the break plays in any daypart.',
      timeWindow: 'Channel time window',
      clearWindow: 'Clear',
      timeWindowHint: 'Empty — any time. The window may cross midnight.',
      nearHour: 'Near the round hour',
      nearHourUnit: 'min before and after :00',
      nearHourHint:
        '0 — no anchoring. Time signals and jingles work this way: the break only plays around :00, not somewhere within the hour.',
      badgeNearHour: '±{{minutes}} min off the hour',
      badgeOnChange: 'on change',
      badgeInterval: 'once per {{minutes}} min',
    },
    bumpers: {
      title: 'Bumpers',
      hint: 'Bumper blocks are shared across channels: look and sound belong to the block, text to its variants. A bumper reaches air as a junction break.',
      empty: 'No bumper blocks yet.',
      newName: 'Block name',
      createTitle: 'Create a bumper block',
      newNamePlaceholder: 'Block name',
      newVariantName: 'New text',
      sampleChannel: 'Preview as channel',
      sampleChannelNone: 'no channel',
      sampleChannelHint: 'The block is shared, but sample values come from the selected channel.',
      name: 'Name',
      font: 'Font',
      fontSans: 'Sans',
      fontSerif: 'Serif',
      colorBg: 'Background (colour 1)',
      colorBg2: 'Background (colour 2)',
      colorAccent: 'Accent',
      colorText: 'Text',
      saveStyle: 'Save look',
      seconds: 's',
      defaultDuration: '≈8 s (jingle)',
      variantsCount: 'texts: {{count}}',
      usedInJunctions: 'in breaks: {{count}}',
      cannotDeleteUsed: 'The block is used by junction breaks — drop the references first.',
      audio: 'Sound',
      audioHint: 'The sound length sets the bumper duration; without it a jingle is synthesised.',
      background: 'Background',
      backgroundFieldHint: 'Block background image; otherwise a palette gradient or a show poster.',
      backgroundPick: 'Pick from gallery',
      backgrounds: {
        Template: 'Block background',
        NextPoster: 'Next show poster',
        NowPoster: 'Previous show poster',
        Clip: 'Existing clip',
      },
      backgroundClip: 'Backing clip',
      pickClip: 'Pick a clip',
      backgroundClipHint:
        'The text is drawn over the video. The clip sets the bumper length; the block’s audio is trimmed to it, and without audio the clip’s own track plays.',
      fileLoaded: 'loaded',
      fileDefault: 'default',
      upload: 'Upload',
      reset: 'Reset',
      variants: 'Text variants',
      variantsHint:
        'Different text over the same music and look. Trigger and background are per variant.',
      addVariant: 'Add text',
      variantName: 'Name',
      trigger: 'Show on',
      triggers: {
        OnShowChange: 'Show change',
        BetweenEpisodes: 'Between episodes',
        Both: 'Both',
      },
      weight: 'Weight',
      lineStyles: { Label: 'Label', Title: 'Title', Caption: 'Caption' },
      lineColors: { Accent: 'Accent', Text: 'Text' },
      addLine: 'Line',
      presets: 'Presets',
      preset_nowNext: 'Now / Next',
      preset_nextAt: 'Next at …',
      preset_channel: 'Channel ident',
      presetNow: 'NOW',
      presetNext: 'NEXT',
      presetNextAt: 'NEXT AT',
      framePreview: 'Frame',
      framePreviewHint: 'Sample substitution: this is how the line looks on air.',
      unknownPlaceholder: 'Unknown placeholder: {{tokens}}',
      volatileHint: 'every airing is unique — the render cache stops working',
      render: 'Render samples',
      rendering: 'Rendering…',
      renderHint: 'A real ffmpeg render of every variant with sound — takes a few seconds.',
      tokens: {
        channel: 'Channel name',
        'channel.number': 'Channel number',
        'now.title': 'Current show',
        'next.title': 'Next show',
        'now.episode': 'Current episode',
        'next.episode': 'Next episode',
        'next.year': 'Next show year',
        'next.genre': 'Next show genre',
        'next.time': 'Next start time',
        'tonight.title': 'Tonight’s programme',
        'tonight.time': 'Tonight’s start time',
        'tomorrow.title': 'Tomorrow’s programme',
        'tomorrow.time': 'Tomorrow’s start time',
        time: 'Bumper airing time',
        date: 'Date',
        weekday: 'Weekday',
        slot: 'Slot title',
      },
    },
    storage: {
      title: 'Storage',
      volume: 'Storage volume',
      volumeUnknown:
        'The file system did not report the volume size — only the storage usage is shown.',
      totalVolume: 'Volume total',
      ours: 'Used by TeleWave',
      foreign: 'Other on the volume',
      foreignHint: 'database, system, foreign files',
      free: 'Free',
      lowSpace: 'Free space is below the threshold ({{threshold}}) — new uploads are rejected.',
      recount: 'Recount',
      computedAt: 'computed at {{time}}',
      breakdown: 'What takes the space',
      filesTotal: 'files: {{count}}',
      files: 'files: {{count}}',
      empty: 'The storage is empty.',
      areas: {
        Assets: 'Programme segments',
        BumperAssets: 'Bumper segments',
        Originals: 'Originals',
        Inbox: 'Inbox',
        ManualInbox: 'Manual inbox',
        Uploads: 'Unfinished uploads',
        BumperSources: 'Bumper sound and backgrounds',
        Images: 'Images',
        Other: 'Other under the root',
      },
      areaHints: {
        Assets: 'HLS segments of the library — usually almost everything',
        BumperAssets: 'rendered bumpers; cleaned up along with the schedule',
        Originals: 'kept only when Storage:KeepOriginals is on',
        Inbox: 'not picked up by the scanner yet',
        ManualInbox: 'taken into shows by hand',
        Uploads: 'staging directory; leftovers mean an aborted upload',
        BumperSources: 'raw block files, not the segments',
        Images: 'posters, stills, logos',
        Other: 'files outside the known directories — usually zero',
      },
    },
    diagnostics: {
      title: 'Diagnostics',
      refresh: 'Refresh',
      serverTime: 'server time {{time}}',
      verdict: {
        ok: 'Links are built over HTTPS ({{origin}}) — forwarding works.',
        proxyNotTrusted:
          'The proxy sends X-Forwarded-Proto: https, but the immediate peer {{ip}} is not trusted — the scheme stayed HTTP, so M3U/EPG links go out over http.',
        protoHeaderMissing:
          'The scheme stayed HTTP and no X-Forwarded-Proto arrives from the proxy. Configure the proxy to send this header.',
        applyHint: 'Add to .env and restart the container:',
      },
      copy: 'Copy',
      copied: 'Copied',
      forwarding: {
        title: 'Proxy forwarding',
        https: 'HTTPS',
        http: 'HTTP',
        remoteIp: 'Immediate peer',
        applied: 'Forwarding applied',
        appliedYes: 'yes — headers trusted',
        appliedNo: 'no — headers discarded',
        forwardLimit: 'Forward limit',
        flags: 'Processed headers',
        knownProxies: 'Known proxies',
        knownNetworks: 'Known networks',
      },
      database: {
        title: 'Database',
        reachable: 'Reachable',
        unreachable: 'Unreachable',
        latency: 'response {{ms}} ms',
      },
      storage: {
        title: 'Storage',
        exists: 'Directory present',
        missing: 'Directory missing',
        writable: 'Writable',
        readOnly: 'Read-only',
        lowSpace: 'Low space',
        root: 'Root',
        free: 'Free / total',
      },
      tools: {
        available: 'Available',
        missing: 'Not found',
      },
      host: {
        title: 'Process and runtime',
        appVersion: 'Build version',
        environment: 'Environment',
        framework: 'Framework',
        os: 'OS',
      },
    },
    telegram: {
      title: 'Telegram',
      enable: 'Bot enabled',
      enabled: 'Enabled',
      disabled: 'Disabled',
      saved: 'Saved, connection verified',
      token: 'Bot token',
      tokenKept: 'set — leave as is',
      tokenHint: 'Issued by @BotFather. Never returned: only the fact that it is set.',
      transport: 'Delivery',
      transports: { Polling: 'Polling (getUpdates)', Webhook: 'Webhook' },
      transportHint: {
        Polling: 'The server pulls updates itself. Works without a public address and via a proxy.',
        Webhook:
          'Telegram calls your HTTPS endpoint. Needs a public domain; a proxy will not help.',
      },
      webhookUrl: 'Webhook URL',
      webhookHint: 'Full https URL down to /api/telegram/webhook. The secret is generated for you.',
      proxy: 'Proxy',
      proxies: { None: 'No proxy' },
      proxyHint: 'How to reach api.telegram.org.',
      proxyHost: 'Host',
      proxyPort: 'Port',
      proxyUser: 'User',
      proxyPassword: 'Password',
      lastContact: 'Last contact',
      subscribers: 'Subscribers',
      noSubscribers: 'Nobody subscribed yet.',
      user: 'User',
      chat: 'Chat',
      channels: 'Channels',
      lastSeen: 'Last seen',
      stopped: 'stopped',
      openChat: 'Open bot chat',
      linkFailed: 'Bot is not configured',
    },
    maintenance: {
      title: 'Maintenance',
      warning: 'These actions are irreversible — data and files are deleted permanently.',
      clearMedia: 'Clear all media',
      clearMediaHint: 'Deletes all uploaded files and their segments, plus channel schedules.',
      confirmClearMedia: 'Permanently delete ALL media files?',
      clearShowMedia: 'Delete show media',
      clearShowMediaHint: "Deletes files of the selected show's episodes and clears its episodes.",
      confirmClearShowMedia: 'Permanently delete all media of the selected show?',
      pickShow: 'Pick a show',
      deleteShows: 'Delete all shows',
      deleteShowsHint: 'Deletes all shows and their episodes. Media files stay in the library.',
      confirmDeleteShows: 'Permanently delete ALL shows?',
      doneCount: 'Deleted: {{count}}',
    },
    settings: {
      title: 'Settings',
      registration: 'Registration',
      registrationHint:
        'When off, new users cannot sign up themselves — only an administrator can create accounts.',
      registrationLabel: 'Allow public registration',
      channelNumbers: 'Switch channels by number',
      channelNumbersHint:
        'Viewers switch channels with the arrow keys, like on a TV set. The channel grid stays available regardless.',
      preferredAudio: 'Preferred audio tracks',
      preferredAudioHint:
        'Comma-separated language codes in priority order (e.g. "rus, eng"). If a file has a track in one of these languages, it is picked during processing (by order); otherwise ffmpeg default. Applies to new processing.',
    },
    metadata: {
      title: 'Metadata',
      pickPoster: 'From gallery',
      name: 'Name',
      originalName: 'Original name (eng)',
      originalNamePlaceholder: 'e.g. Family Guy',
      originalNameHint: 'Metadata is looked up by this; screens still show the regular name.',
      sourceLabel: 'Source',
      searchBtn: 'Search',
      nothingFound: 'Nothing found',
      apply: 'Apply',
      applied: 'Metadata applied',
      overview: 'Overview',
      year: 'Year',
      clear: 'Clear',
      noPoster: 'No poster',
      refreshEpisodes: 'Refresh episodes',
      refreshing: 'Refreshing…',
      refreshedCount: 'Episodes updated: {{count}}',
      findMissing: 'Find missing episodes',
      missingTitle: 'Missing episodes',
      missingNoSeasons: 'No loaded episodes with recognized numbers.',
      seasonN: 'Season {{n}}',
      loadedOf: 'loaded {{loaded}} of {{total}}',
      missingUnknown: 'The source did not return the episode count for this season.',
      missingNone: 'All episodes present.',
      missingList: 'Missing',
      findMissingSeasons: 'Find missing seasons',
      missingSeasonsTitle: 'Missing seasons',
      missingSeasonsUnknownTotal: 'The source did not return the season list for this series.',
      missingSeasonsNone: 'All seasons present.',
      missingSeasonsList: 'Seasons with no loaded episodes',
      missingSeasonsUnknown: 'The source does not know these loaded seasons: {{list}}.',
    },
  },
}