Skip to content

The all-in-one local AI studio for your desktop: chat, image and video generation and a coding agent in one free, open source app. Windows and Linux. No Docker, no terminal, no cloud required.

27.7 KB
Raw Blame
/**
 * Texts of the strand "remote". Every text a user can read in this strand's
 * screens lives here, not in JSX, so the guard reads them in one place.
 * English, short sentences, no dashes, "Tap" instead of the desktop verb,
 * "this phone" instead of "your machine".
 *
 * The sentences for a failed connection do not live here: they come ready
 * from the logic layer (src/mobile/remote/remoteErrors.ts) and already name
 * the next step. This file only adds titles, buttons and the hints around.
 */
export const REMOTE_STRINGS = {
  // ---- R1 Remote desktop ----
  home: {
    loading: 'Loading remote desktop',
    introTitle: 'Use the models on your desktop',
    introText: 'This phone can chat with the models that run on your desktop LU. Both have to be on the same Wi-Fi.',
    steps: [
      'Open LU on your desktop and turn on Remote Access.',
      'Scan the QR code it shows, or type the address.',
      'Enter the 6 digit code from the desktop.',
    ],
    /** The second step on a phone that cannot scan inside LU. */
    stepTypeAddress: 'Type the address it shows under the QR code.',
    stepsLabel: 'How to connect',
    scan: 'Scan QR code',
    enter: 'Enter address and passcode',
    help: 'How it works',
    connectedTo: (name: string) => `Connected to ${name}`,
    /** Under the name of the computer while the phone reaches it over the internet (the tunnel address is not written out). */
    viaInternet: 'via internet link',
    connectedSub: (route: string, version: string) => (version ? `${route}, desktop LU ${version}` : route),
    disconnect: 'Disconnect',
    disconnectQuestion: (name: string) => `Disconnect from ${name}?`,
    disconnectText: 'The session ends on the desktop too. Your remote chats stay on this phone. To come back you need the current code.',
    disconnected: 'Disconnected. Your remote chats are still here.',
    details: 'Connection details',
    newChat: 'New remote chat',
    chatsTitle: 'Remote chats',
    chatsOn: (name: string) => `Chats on ${name}`,
    chatsOtherNote: 'Chats of another desktop can be read here. To continue one, connect to that desktop.',
    chatsEmptyTitle: 'No remote chats yet',
    chatsEmptyText: 'Start one and the answer comes from the model on your desktop.',
    chatsOfflineNote: 'You can read these chats. To write, connect to your desktop first.',
    moreFor: (title: string) => `More for ${title}`,
    emptyChatPreview: 'No messages yet',
    answering: 'Answering',
    connecting: (address: string) => `Connecting to ${address}`,
    connectingText: 'Checking your desktop. Your remote chats stay readable.',
    pairing: (address: string) => `Pairing with ${address}`,
    needsCodeTitle: 'Enter the code to pair',
    needsCodeText: (address: string) => `Your desktop at ${address} answered. Enter the 6 digit code it shows to pair this phone.`,
    sessionEndedTitle: 'Pair again',
    enterCode: 'Enter code',
    unreachableTitle: 'Could not reach your desktop',
    blockedTitle: 'Your desktop paused this session',
    tryAgain: 'Try again',
    tryAgainAfterRestart: 'Try again after restart',
    scanNew: 'Scan new QR code',
    forget: 'Forget this desktop',
    forgetQuestion: (name: string) => `Forget ${name}?`,
    forgetText: 'The address is removed from this phone. Your remote chats stay.',
    forgotten: 'Desktop forgotten. Your remote chats are still here.',
    knownTitle: 'Recent desktops',
    knownSub: (route: string, when: string) => `${route}, last used ${when}`,
    knownTunnelSub: 'Internet link. It changes every time Remote Access restarts.',
    knownRemove: (name: string) => `Remove ${name}`,
    knownRemoveQuestion: (name: string) => `Remove ${name} from this list?`,
    knownRemoveText: 'Only the remembered address is removed.',
    remove: 'Remove',
    cancel: 'Cancel',
    whatToCheck: 'What to check',
  },

  // ---- R2 Connect to desktop ----
  connect: {
    title: 'Connect to desktop',
    address: 'Address',
    addressPlaceholder: '192.168.1.20:11435',
    addressHint: 'Shown under the QR code on your desktop.',
    passcode: 'Passcode',
    passcodePlaceholder: '6 digits',
    passcodeHint: 'Shown next to the QR code on your desktop. It changes every 15 minutes.',
    passcodeShort: 'Enter all 6 digits of the code shown on your desktop.',
    passcodeMissing: 'Your desktop answered. Now enter the 6 digit code it shows.',
    submit: 'Connect',
    submitWait: (seconds: number) => `Wait ${seconds} ${seconds === 1 ? 'second' : 'seconds'}`,
    checking: (address: string) => `Checking ${address}`,
    pairing: 'Pairing',
    scanInstead: 'Scan QR code instead',
    help: 'How it works',
    connected: (name: string) => `Connected to ${name}`,
    insecureNote: 'On Wi-Fi nothing is encrypted. The code you type and everything you send can be read by others on the same network. Pair only on your own network, one you trust, never on public or shared Wi-Fi.',
    fromLink: 'This address came from a link. Check that it is the one your desktop shows before you connect.',
    fromScanWithCode: 'This QR code carried an address and a code. The QR code of your desktop never contains the code. Connect only if address and code are the ones your desktop shows.',
    fromLinkWithCode: 'Address and code came from a link. Check that they are the ones your desktop shows before you connect.',
    blockedTitle: 'Your desktop paused this session',
    // Sealed channel (3.0.7): QR code v2 and the confirmation at the computer.
    sealedTitle: (name: string) => `Pair with ${name}?`,
    sealedText: 'This QR code comes from LU on your computer. The connection is encrypted end to end, on Wi-Fi and over the internet.',
    sealedSubmit: 'Pair',
    confirmTitle: 'Confirm on your computer',
    confirmText: (name: string) => `Allow this phone in LU on ${name}. This page goes on by itself.`,
    confirmCode: (sas: string) => `Check that your computer shows ${sas.slice(0, 3)} ${sas.slice(3)}. If it shows other digits, choose Deny there.`,
    confirmDevice: (fingerprint: string) => `This phone has the device ID ${fingerprint}. Your computer shows the same.`,
    // H1: the computer names itself on Wi-Fi only while its pairing panel is open.
    openPairingRetry: 'Try again',
  },

  // ---- R3 Scan code ----
  scan: {
    title: 'Scan code',
    close: 'Close',
    enterInstead: 'Enter address instead',
    torchOn: 'Turn the light on',
    torchOff: 'Turn the light off',
    aim: 'Point the camera at the QR code on your desktop.',
    starting: 'Starting the camera',
    deniedTitle: 'LU needs the camera to scan the code.',
    deniedText: 'Allow the camera for LU in the settings of this phone, or type the address instead.',
    openSettings: 'Open system settings',
    settingsFailed: 'Open the settings of this phone yourself and allow the camera for LU.',
    noScannerTitle: 'This phone cannot scan codes inside LU',
    noScannerText: 'Type the address shown under the QR code on your desktop instead. It works the same way.',
    /** Android: the app does not ask for the camera at all, so there is nothing to allow in the settings. */
    noCameraText: 'LU does not use the camera on this phone, so it cannot read the code. Type the address shown under the QR code on your desktop instead. It works the same way.',
    closedTitle: 'No code scanned',
    closedText: 'The scanner was closed before it found a code.',
    noCodeTitle: 'No QR code in the photo',
    noCodeText: 'Take the photo again, close enough that the QR code on your desktop fills most of it.',
    again: 'Scan again',
    wrongTitle: 'That is not a code from LU Remote Access',
    wrongText: 'Scan the QR code that LU shows on your desktop under Remote Access.',
    found: (address: string) => `Found ${address}`,
    cameraFailedTitle: 'The camera did not start',
    cameraFailedText: 'Close other apps that use the camera and try again, or type the address instead.',
  },

  // ---- R4 Remote chat ----
  chat: {
    title: 'Remote chat',
    onDesktop: (name: string) => `On ${name}`,
    notConnected: 'Not connected',
    message: 'Message',
    placeholder: 'Message your desktop',
    menu: 'Chat menu',
    emptyTitle: 'Ask the model on your desktop',
    emptyText: 'Answers are made on your desktop and arrive here in one piece.',
    runsOnDesktop: 'This chat runs on your desktop. The messages are also shown in LU there.',
    working: 'Your desktop is working on it',
    workingText: 'The answer arrives in one piece when it is done.',
    stopped: 'Stopped',
    unanswered: 'This message has no answer yet.',
    interrupted: 'This answer was interrupted when the app went to the background.',
    tryAgain: 'Try again',
    enterCode: 'Enter code',
    reconnect: 'Reconnect',
    connectionLostTitle: 'Connection to your desktop was lost.',
    sessionTitle: 'Pair again to keep chatting',
    connectingBanner: (address: string) => `Checking your desktop at ${address}`,
    unpairedTitle: 'Not connected to a desktop',
    unpairedText: 'You can read this chat. To write, connect to your desktop first.',
    connect: 'Connect',
    sendBlockedOffline: 'not connected',
    sendBlockedBusy: 'an answer is still coming in',
    sendBlockedOther: 'this chat belongs to another desktop',
    agentOnDesktop: 'Agent mode is on. Tools run on your desktop with the permissions that are set there.',
    workingAgent: 'Your desktop is working through the steps',
    otherDesktopTitle: (name: string) => `This chat was held with ${name}`,
    otherDesktopText: (current: string) => `You can read it here. To continue it, connect to that desktop. Right now you are connected to ${current}.`,
    otherDesktopToast: 'This chat belongs to another desktop. Your message is kept.',
    newChatHere: 'New chat on this desktop',
    imagesLostToast: 'The photos of this message are no longer on this phone. Send the message again with the photos.',
    attach: 'Add photos',
    photoChip: (n: number) => (n === 1 ? '1 photo' : `${n} photos`),
    removePhoto: (name: string) => `Remove ${name}`,
    photoAlt: 'Attached photo',
    endMaxSteps: 'The model stopped after the highest number of steps.',
    endToolErrors: 'The model stopped because several steps in a row failed.',
    endLooping: 'Stopped because the model kept repeating the same steps.',
    endCostLimit: 'Paused: agent runs from this phone sent a lot to the model in the last hour. Send a message to go on.',
    missingTitle: 'This remote chat is not on this phone',
    missingText: 'It may have been deleted. Your other remote chats are in the list.',
    backToList: 'Back to remote chats',
    modelNone: 'Choose a model',
    noModelToast: 'Choose a model on your desktop first. Your message is kept.',
    you: 'You',
    desktop: 'Desktop',
    more: 'More',
    moreForAnswer: 'More for this answer',
    moreForQuestion: 'More for your message',
    busyToast: 'Wait until the current answer is done.',
    notConnectedToast: 'Your desktop is not connected right now. Nothing was changed.',
    thinking: 'Thinking',
    options: 'Chat options',
    loading: 'Loading chat',
  },

  // ---- sheets of R4 and R1 ----
  model: {
    title: 'Model on your desktop',
    emptyTitle: 'No models found on your desktop',
    emptyText: 'Load a model there, then tap Refresh.',
    refresh: 'Refresh',
    refreshing: 'Asking your desktop',
    desktopDefault: 'Chosen on the desktop',
    groupLabel: 'Models on your desktop',
    notConnected: 'Connect to your desktop to see its models.',
  },
  attach: {
    title: 'Add photos',
    camera: 'Take a photo',
    library: 'Choose from library',
    librarySub: (max: number) => `Up to ${max} photos per message`,
    preparing: 'Preparing',
    hint: 'Photos are sent to the model on your desktop. It needs a model that can read images.',
    tooMany: (max: number) => `A message takes up to ${max} photos.`,
    failed: 'This photo could not be opened. Try another one.',
    cameraFailed: 'The camera could not be opened. Choose a photo from the library.',
    /** The sheet was opened without a remote chat: there is no message the photo could go with. */
    noChat: 'Open a chat with your desktop first.',
  },
  steps: {
    title: (n: number) => (n === 1 ? '1 step on your desktop' : `${n} steps on your desktop`),
    running: 'Running',
    done: 'Done',
    failed: 'Failed',
    input: 'Input',
    result: 'Result',
    noResult: 'No result.',
    needsPermission: (name: string) => `"${name}" is turned off on your desktop. Turn it on there under Settings, Remote Permissions.`,
    tools: {
      web_search: 'Web search',
      web_fetch: 'Read web page',
      file_read: 'Read file',
      file_write: 'Write file',
      file_edit: 'Edit file',
      file_list: 'List files',
      file_search: 'Search files',
      shell_execute: 'Terminal command',
      image_generate: 'Make an image',
      video_generate: 'Make a video',
    },
    /** A17: what a step made on the computer, shown at the step. */
    madeLabel: (n: number, total: number) => (total > 1 ? `Result ${n} of ${total}` : 'Result'),
    open: 'Open',
    save: 'Save',
    gone: 'This result is no longer on this phone.',
  },
  options: {
    title: 'Chat options',
    /** Prompt v2: the model choice moved from beside the field into this sheet. */
    model: 'Model',
    modelSub: 'Runs on your desktop',
    settingsName: (summary: string) => `Chat options: ${summary}`,
    agentPart: 'Agent',
    thinkingPart: 'Thinking',
    agent: 'Agent mode',
    agentSub: (abilities: string) => `The model can use tools on your desktop: ${abilities}.`,
    agentHint: 'Files and terminal commands are switched on your desktop under Settings, Remote Permissions.',
    abilityWeb: 'web search',
    abilityFiles: 'files',
    abilityShell: 'terminal commands',
    abilityImages: 'images',
    abilityVideos: 'videos',
    cavemanTitle: 'Short answers (Caveman)',
    cavemanOff: 'Off',
    cavemanLite: 'Lite',
    cavemanLiteSub: 'Fewer filler words',
    cavemanFull: 'Full',
    cavemanFullSub: 'Short fragments',
    cavemanUltra: 'Ultra',
    cavemanUltraSub: 'As few words as possible',
    thinking: 'Thinking',
    thinkingOn: 'The model reasons before it answers. Slower, often better.',
    thinkingUnsupported: 'This model cannot think step by step.',
    personaTitle: 'Persona',
    personaDefault: 'Desktop default',
    personaDefaultSub: 'The system prompt that was set on the desktop',
  },
  message: {
    title: 'Message',
    none: 'No message is selected.',
    copy: 'Copy text',
    copied: 'Copied',
    copyFailed: 'Could not copy. Select the text and copy it yourself.',
    report: 'Report',
    retry: 'Try again',
    regenerate: 'Regenerate',
    regenerateSub: 'Drops this answer and asks your desktop again',
    regenerateLaterSub: 'Drops this answer and everything after it, then asks again',
    edit: 'Edit and resend',
    editSub: 'Everything after this message is dropped',
    editTitle: 'Edit message',
    editField: 'Your message',
    editHint: 'Your desktop answers the changed message. Everything after it in this chat is dropped.',
    editSend: 'Send again',
    editEmpty: 'Write a message first.',
    whyBusy: 'Wait until the current answer is done',
    whyOffline: 'Your desktop is not connected',
    whyForeign: 'This chat belongs to another desktop',
  },
  chatMenu: {
    title: 'Remote chat',
    none: 'No chat is selected.',
    rename: 'Rename',
    renameQuestion: 'Rename this chat',
    renameField: 'Title',
    renameConfirm: 'Save',
    delete: 'Delete chat',
    deleteQuestion: (title: string) => `Delete ${title}?`,
    deleteText: 'The chat is removed from this phone. The copy in LU on your desktop stays.',
    deleted: 'Chat deleted',
    connection: 'Connection details',
  },
  connection: {
    title: 'Connection',
    name: 'Computer',
    address: 'Address',
    route: 'Connected over',
    version: 'Desktop LU',
    versionUnknown: 'unknown',
    pairedSince: 'Paired since',
    notPaired: 'not paired',
    status: 'Status',
    permissionsTitle: 'What the desktop allows',
    permissionsHint: 'Change these on your desktop under Remote Permissions.',
    filesystem: 'Files',
    downloads: 'Model downloads',
    processControl: 'Process control',
    shell: 'Terminal commands',
    allowed: 'Allowed',
    notAllowed: 'Not allowed',
    insecure: 'On Wi-Fi the connection is not encrypted. Others on the same network can read it. Use it only on your own network, one you trust.',
    secure: 'The internet link is encrypted.',
    none: 'No desktop is set up on this phone.',
  },
  status: {
    unpaired: 'Not set up',
    connecting: 'Checking',
    'needs-code': 'Code needed',
    pairing: 'Pairing',
    connected: 'Connected',
    offline: 'Not reachable',
    blocked: 'Paused by the desktop',
  },
  route: {
    lan: 'Wi-Fi',
    tunnel: 'Internet link',
    loopback: 'This device',
    public: 'Internet address',
  },

  // ---- hints for "not reachable", by the way the desktop is reached ----
  checks: {
    open: 'LU is open on the desktop and Remote Access is turned on.',
    sameWifi: 'This phone and the desktop are on the same Wi-Fi. Mobile data does not reach it.',
    guest: 'Guest networks often keep devices apart. Use the main network.',
    firewall: 'The firewall on the desktop allows LU. The desktop asks once when Remote Access starts.',
    iosLocal: 'LU may find devices on your network: in the settings of this phone, open LU and turn on Local Network.',
    tunnel: 'The internet link changes every time Remote Access restarts. Scan the QR code again.',
    phoneOffline: 'This phone has no network connection right now. Turn on Wi-Fi.',
    address: 'The address is the one shown under the QR code, with the numbers after the colon.',
  },

  // ---- R5 How it works ----
  help: {
    title: 'How it works',
    whatTitle: 'What it does',
    what: [
      'Remote desktop turns this phone into a second screen for the LU on your computer.',
      'The models run on the desktop, not on this phone. So you can use models that are too large for a phone, and this phone stays cool.',
      'An answer arrives in one piece when the desktop has finished it.',
    ],
    /** The second line of "How to connect" on a phone that cannot scan inside LU. */
    howTypeAddress: 'On this phone, type the address shown under the QR code. Then enter the code.',
    howTitle: 'How to connect',
    how: [
      'Open LU on your desktop and turn on Remote Access. It shows a QR code, an address and a 6 digit code.',
      'On this phone, scan the QR code or type the address. Then enter the code.',
      'Both devices have to be on the same Wi-Fi. For use from elsewhere the desktop can open an internet link, which changes every time it restarts.',
      'A session ends after an hour without use and after a day at the latest. Then you enter the current code again.',
    ],
    privateTitle: 'What stays private',
    private: [
      'Your messages go from this phone to your desktop and nowhere else. On Wi-Fi the code, your messages and the key of the session travel without encryption. Pair only on your own network, one you trust, never on public or shared Wi-Fi.',
      'The code is never saved on this phone. The remote chats are saved here and stay readable without the desktop.',
      'Files, terminal commands and downloads on the desktop stay off until you allow them there under Remote Permissions.',
    ],
    connectNow: 'Connect now',
  },

  // ---- G4 the error screen ----
  fatal: {
    copyReport: 'Copy report',
    reportCopied: 'Report copied. Paste it into a message to the makers of LU.',
    reportNotCopied: 'Could not copy the report. Select the text below and copy it yourself.',
    reportLabel: 'Report',
    restart: 'Restart LU',
    safe: 'Nothing was deleted. Restarting keeps your chats, models and settings.',
  },

  // ---- G7 the offline line ----
  offline: {
    checking: 'Checking the connection',
  },

  // ---- G8 the notice after a return ----
  resume: {
    closedTitle: 'LU was closed while answering',
    // Only what the app knows: it was closed in the middle of an answer. Why, it cannot tell
    // (the system took the memory, or the user ended it), so it does not say.
    closedText: 'The answer is saved up to that point.',
    closedTextNothing: 'Nothing of the answer was saved yet. Ask again to get it.',
    // The number counts only answers a part is saved of (resilience/ResumeNotice.tsx, `resumeShown`).
    closedTextMany: (count: number) => `${count} answers were cut short. What had arrived of them is saved.`,
    // Said when a different chat is on the screen, so the notice is not read as news about the open one.
    closedElsewhere: (title: string) => (title ? `It belongs to another chat: ${title}.` : 'It belongs to another chat.'),
    askAgain: 'Ask again',
    continueAnswer: 'Continue answer',
    openChat: 'Open chat',
    dismiss: 'Dismiss',
    jobsPicked: (count: number) => (count === 1 ? 'Picked up 1 running job.' : `Picked up ${count} running jobs.`),
    jobsWhere: 'The result goes to your gallery.',
    openGallery: 'Open gallery',
  },

  // ---- G12 storage ----
  storage: {
    full: 'LU is running out of space for chats.',
    manage: 'Manage storage',
    // The phone is out of storage (finding F11 of check 4 on Android). LU tries again by itself while this line stands.
    notSaved: 'Your phone is out of storage. This chat is not saved yet. Free up space, then try again.',
    // The stored chats could not be read, so nothing is written over them.
    notSavedUnreadable: 'LU cannot read your saved chats right now, so new messages are not saved. Your saved chats are not changed. This happens when the phone is out of storage: free up space, then try again.',
    // A write failed for another reason.
    notSavedOther: 'LU could not save this chat yet. It stays here while the app is open, and LU keeps trying.',
    notSavedSetting: 'Your phone is out of storage. This setting is not saved yet. Free up space, then try again.',
    notSavedSettingOther: 'LU could not save this setting yet. It holds while the app is open, and LU keeps trying.',
    // D-VW, check of package 17: there is room again, but the storage of the web view stays broken until LU restarts.
    notSavedRestart: 'Your phone has room again, but LU can only save after a restart.',
    // NH-T, check of package 18: how to restart, as the line has no button for it (LU cannot restart itself, and
    // "Try again" cannot help before a restart).
    restartHowAndroid: 'Close LU completely: swipe it away in your recent apps, then open it again.',
    restartHowIos: 'Close LU completely: swipe it away in the app switcher, then open it again.',
    tryAgain: 'Try again',
    slow: 'Saving is slower than usual. Your chats are safe.',
    savedAgain: 'Saved again. Your chats are on this phone.',
  },

  // ---- A17: shared chats of the computer (CHATS-V1) ----
  shared: {
    /** Prompt v2: the button under the field that opens the model choice of a shared chat. */
    modelName: (name: string) => `Model: ${name}. Change model`,
    listTitle: 'Chats on your computer',
    listEmptyTitle: 'No shared chats',
    listEmptyText: 'On your computer, choose "Continue on phone" in a chat, or start a new one here.',
    listError: 'The chats of your computer could not be loaded.',
    newChat: 'New chat on your computer',
    newTitle: 'New chat on your computer',
    newText: 'The chat runs on your computer and shows up there as well.',
    modeChat: 'Chat',
    modeChatSub: 'Talk with the model on your computer',
    modeAgent: 'Agent',
    modeAgentSub: 'The model uses tools on your computer: web, files, terminal',
    modeCode: 'Code',
    modeCodeSub: 'Work on code in a folder of your computer',
    creating: 'Starting the chat',
    working: 'Working',
    unread: (n: number) => (n === 1 ? '1 new' : `${n} new`),
    unreadLabel: (n: number) => (n === 1 ? '1 new message' : `${n} new messages`),
    mode: { chat: 'Chat', agent: 'Agent', code: 'Code' } as Record<string, string>,
    phoneOnly: 'Chats on this phone',
    loading: 'Loading the chat',
    loadOlder: 'Load earlier messages',
    loadingOlder: 'Loading',
    empty: 'This chat is empty. Write the first message.',
    fromDesktop: 'Typed on your computer',
    placeholder: 'Message your computer',
    waiting: 'Waiting to send',
    sending: 'Sending',
    failed: 'Not sent',
    retry: 'Send again',
    tryAgain: 'Try again',
    waitingDesk: 'Waiting for your computer, someone is typing there',
    turnErrorTitle: 'Your computer did not answer this',
    model: 'Model',
    modelTitle: 'Model on your computer',
    modelSub: 'Used for the next messages of this chat.',
    remove: 'Remove',
    stop: 'Stop',
    stopFailed: 'The answer could not be stopped.',
    toolRunning: 'Running',
    toolDone: 'Done',
    toolFailed: 'Failed',
    toolRan: (tool: string) => `Ran: ${tool}`,
    toolFailedLine: (tool: string) => `Failed: ${tool}`,
    toolName: 'Tool',
    approvalTitle: (tool: string) => `Allow ${tool}?`,
    approvalText: 'Your computer asks before it runs this.',
    allowOnce: 'Allow once',
    allowChat: 'Always in this chat',
    deny: 'Deny',
    approvedOnce: 'Allowed once',
    approvedChat: 'Allowed in this chat',
    denied: 'Denied',
    decidedOnDesktop: 'Decided on your computer',
    attach: 'Add photos or files',
    attachPhotos: 'Photos',
    attachFiles: 'PDF or text file',
    removeFile: (name: string) => `Remove ${name}`,
    fileTypes: 'Only photos, PDF and text files can go to your computer.',
    fileTooLarge: 'This file is too large to send to your computer.',
    attachment: (name: string) => name || 'Attachment',
    tasks: 'Running on your computer',
    menuTasks: 'Running on your computer',
  },
  tasks: {
    title: 'Running on your computer',
    empty: 'Nothing is running on your computer.',
    loading: 'Asking your computer',
    chat: 'Answer',
    create: 'Render',
    stop: 'Stop',
    stopLabel: (title: string) => `Stop ${title}`,
    stopped: 'Stopped.',
    stopFailed: 'It could not be stopped.',
    open: 'Open',
    refresh: 'Refresh',
  },
  line: {
    label: 'Connection to your computer',
    retryNow: 'Try now',
    lanBlocked: 'Wi-Fi is blocked on your computer, see LU there',
  },
  notices: {
    answer: 'Answer ready',
    render: 'Render ready',
    approval: 'Approval needed',
    renderText: 'Your computer finished it. It is in the gallery.',
    approvalText: (what: string) => (what ? `Your computer asks before it runs ${what}.` : 'Your computer asks before it runs a tool.'),
    setting: 'Notices from your computer',
    settingSub: 'Answer ready, render ready and approval needed, while LU is not on the screen.',
    settingLimit: 'They come while LU still runs in the background. When the system has closed LU, none can come.',
    denied: 'Notifications of LU are turned off in the settings of your phone.',
    offerTitle: 'Get notified when your computer is done?',
    offerText: 'LU tells you when an answer or a render is ready, or when your computer asks before it runs a tool, also while LU is not on the screen.',
    offerAllow: 'Allow',
    offerNotNow: 'Not now',
    openSettings: 'Open settings',
    settingsFailed: 'The settings of your phone could not be opened.',
  },
  // ---- Voice over remote (GitHub #212) ----
  voice: {
    mic: 'Talk to your computer. Hold to talk, tap for hands free',
    listening: 'Listening',
    talk: 'Talk, let go to send',
    sending: 'Your computer writes it down',
    waiting: 'LU is answering',
    speaking: 'Reading the answer',
    interrupt: 'Tap to talk',
    end: 'End',
    endName: 'End voice',
    nothingHeard: 'Nothing was heard. Hold the microphone a little longer.',
    micDenied: 'LU has no access to the microphone. Allow it in the system settings.',
    noMic: 'This phone gives LU no microphone.',
    notConnected: 'Connect to your computer to talk to it.',
    gaveUp: 'Hands free ended after a long silence.',
    speakFailed: 'The answer could not be read aloud.',
  },
} as const

export type RemoteStatusKey = keyof typeof REMOTE_STRINGS.status