react-native-ensys-camera-x 1.0.7

package/src/localization.ts

@@ -0,0 +1,1947 @@
+import React, {
+  createContext,
+  useContext,
+  useEffect,
+  useMemo,
+  useState,
+  type ReactNode,
+} from 'react';
+import { I18nManager, NativeModules, StyleSheet } from 'react-native';
+import type { TextStyle, ViewStyle } from 'react-native';
+import {
+  DEFAULT_LOCALE,
+  isRtlLocale,
+  normalizeLocale,
+  resolveLocaleTranslations,
+} from './locales';
+
+export interface CameraTranslations {
+  // Common / General
+  all: string;
+  photos: string;
+  videos: string;
+  documents: string;
+  cancel: string;
+  done: string;
+  ok: string;
+  use: string;
+  trim: string;
+  selectCover: string;
+  add: string;
+  addMore: string;
+  /** The "Add more" button on the editor's media strip, `+` prefix included. */
+  addMorePlus: string;
+  /** Position of the visible item in a multi-item preview, e.g. `2/5`. */
+  mediaCounter: string;
+  /** The selected trim range under a video, e.g. `0:03  –  0:12`. */
+  trimRangeLabel: string;
+  /** A zero timestamp, shown before a clip's duration is known. */
+  durationZero: string;
+  /**
+   * File-size units. `{0}` is the number, already formatted with the active
+   * language's digits and decimal separator — translate only the unit itself.
+   */
+  fileSizeBytes: string;
+  fileSizeKb: string;
+  fileSizeMb: string;
+  fileSizeGb: string;
+  /**
+   * Date pattern for the gallery's day headers, in Android `SimpleDateFormat`
+   * syntax. Month and day names come from the active language automatically;
+   * override this only to change field order, e.g. `dd MMM yyyy`.
+   */
+  dateFormatPattern: string;
+  openSettings: string;
+  close: string;
+  back: string;
+  send: string;
+  save: string;
+  delete: string;
+  deleteFile: string;
+  clear: string;
+  clearFilter: string;
+  /** Filter-picker "None" label while a filter is active; `{0}` = filter name. */
+  filterClearSuffix: string;
+  audio: string;
+  document: string;
+  openingCamera: string;
+  initializingCamera: string;
+  gallery: string;
+  selectedCount: string;
+  openGallery: string;
+  openWith: string;
+  libraryEmptyTitle: string;
+  libraryEmptyMessage: string;
+  /** `ACTION_SEND` chooser title on Android (the native share-sheet header). */
+  share: string;
+
+  // CustomCameraActivity / Camera Setup
+  photoMode: string;
+  videoMode: string;
+  recording: string;
+  // Hold-to-record gesture
+  shutterCapture: string;
+  shutterHoldToRecord: string;
+  holdForVideo: string;
+  slideUpToLock: string;
+  slideToCancel: string;
+  cancelRecording: string;
+  releaseToCancel: string;
+  recordingLocked: string;
+  flashOn: string;
+  flashOff: string;
+  switchCamera: string;
+  toggleFlashlight: string;
+  pointCameraAtBarcode: string;
+  closeScanner: string;
+  permissionRequiredTitle: string;
+  permissionRequiredMessage: string;
+  /**
+   * Permissions are requested just-in-time, one feature at a time: the camera on launch, the
+   * gallery on the first gallery open, the microphone on the first video recording. Each of
+   * those has its own "permanently denied" copy so the message names only what is missing.
+   */
+  permissionCameraRequiredMessage: string;
+  permissionMediaRequiredTitle: string;
+  permissionMediaRequiredMessage: string;
+  /**
+   * Native pre-permission rationale shown BEFORE the camera's system permission dialog.
+   * Its whole purpose is to steer the user to the persistent "While using the app" grant
+   * rather than the one-time "Only this time" option — the latter is revoked on process
+   * death / reboot and forces a re-prompt on the next cold start.
+   */
+  permissionRationaleCameraPersistentMessage: string;
+  /** Positive button on the native pre-permission rationale ("Continue"). */
+  permissionContinue: string;
+  /**
+   * Default rationale texts for the JS-side `PermissionsAndroid` flow
+   * (`requestCameraPermission` / `requestStoragePermission` /
+   * `requestMicrophonePermission`). The native in-camera permission dialogs use
+   * the `permission*Required*` keys above; these cover hosts that request
+   * permission ahead of time through the exported helpers.
+   */
+  permissionRationaleCameraTitle: string;
+  permissionRationaleCameraMessage: string;
+  permissionRationaleStorageTitle: string;
+  permissionRationaleStorageMessage: string;
+  permissionRationaleMicrophoneTitle: string;
+  permissionRationaleMicrophoneMessage: string;
+  /** Positive button on the JS permission rationale. */
+  permissionGrant: string;
+  /** Negative button on the JS permission rationale. */
+  permissionDeny: string;
+  cameraUnavailable: string;
+  cameraNotFound: string;
+  cameraInitializationFailed: string;
+  cameraPermissionDenied: string;
+  cameraPermissionRequired: string;
+  tapToScan: string;
+
+  // MediaPreviewEditor & Feedback
+  preparingVideo: string;
+  selectionTooShort: string;
+  trimming: string;
+  trimFailed: string;
+  cropping: string;
+  cropFailed: string;
+  savingCover: string;
+  couldNotSetCover: string;
+  coverUpdated: string;
+  saving: string;
+  savedToGallery: string;
+  failedToSaveMedia: string;
+  sending: string;
+  failedToSendMedia: string; // expects {0} (error message)
+  couldNotSaveEditsSendingOriginal: string;
+  sendFailed: string;
+  sendFailedWithMessage: string; // expects {0}
+  addTextTitle: string;
+  addTextButton: string;
+  typeTextHint: string;
+  sizeLabel: string; // expects {0} (size in bytes formatted)
+  drawOnImage: string;
+  preparing: string;
+  couldNotPrepareEditsForCropping: string;
+  useTwoFingersToResizeOrRotate: string;
+  operationTimedOut: string;
+  audioMuted: string;
+  audioOn: string;
+  compressVideo: string;
+  originalVideo: string;
+  /** The overflow menu's compression row on a still preview, the counterpart of `compressVideo`. */
+  compressImage: string;
+  /** The still menu's first row: send the image at its original size. */
+  originalImage: string;
+  /**
+   * The overflow menu's quality-strategy row, and its accessibility label. Governs what BOTH
+   * Compress and Save As produce; its applied value is one of the three `profile*` names below.
+   */
+  compressionProfile: string;
+  /**
+   * The default quality strategy: the balance of size, quality, speed and RAM chosen for the
+   * device it runs on.
+   */
+  profileRecommended: string;
+  /**
+   * Result message when no re-encode of a still came out smaller than the original — there is
+   * nothing left to compress, so the original is kept. Not an error.
+   */
+  compressionAlreadyMinimal: string;
+  /**
+   * A compression dropdown row plus the size it is expected to produce; `{0}` = the row's
+   * label, `{1}` = the formatted size. The tilde marks it as an estimate.
+   */
+  compressEstimatedSize: string;
+  /**
+   * The "Original video" / "Original image" row plus its real file size; `{0}` = label,
+   * `{1}` = formatted size.
+   */
+  compressOriginalSize: string;
+  /**
+   * Two formatted sizes as one span, for a compression row whose output is predicted as a range
+   * rather than a single figure; `{0}` = the low end, `{1}` = the high end.
+   *
+   * A clip is re-encoded at a TARGET bit rate, which the encoder spends around rather than hits
+   * exactly, so its predicted size is honestly a band ("5.8 – 7.1 MB"). The low end drops the unit
+   * when both ends share one, so translations should keep `{0}` unit-less. Wrapped by
+   * `compressOriginalSize`, since the band already reads as an approximation and does not also take
+   * the tilde.
+   */
+  compressSizeRange: string;
+  /**
+   * The message shown when a compression finishes; `{0}` = the formatted output size, `{1}` = whole
+   * percent smaller than the original.
+   *
+   * A STILL quotes its two REAL files (the copy just written and the source it came from): a still
+   * is a byte-target search that lands on the size the menu quoted, so the measured figure is right.
+   * A CLIP is quoted PROPORTIONALLY instead — the original with the chosen percent removed, and the
+   * chosen percent as the saving — because a video transcode copies the audio + container through
+   * untouched, so its produced file stays well above the picked level at 70–99% and reads as the
+   * wrong size; the menu quotes that same proportion, so the two agree and "N% smaller" always means
+   * "N% of the original removed". Neither comes from the tilde-marked estimate ladder. A translation
+   * must keep both placeholders.
+   */
+  compressedToSize: string;
+  /**
+   * The same message without a saving; `{0}` = the compressed file's formatted size. Used when the
+   * original's size cannot be measured, and when the copy did not actually come out smaller —
+   * quoting "0% smaller" in either case would state something untrue.
+   */
+  compressedToSizeOnly: string;
+  /** Shown when a compression could not produce a usable file. */
+  compressionFailed: string;
+  /**
+   * The compression progress overlay: a single centred line counting the ESTIMATED time
+   * remaining down to one second; `{0}` = whole seconds left.
+   */
+  compressingSecondsLeft: string;
+  /**
+   * The line that replaces the countdown when the encode outlives its estimate, shown until it
+   * finishes rather than letting the count run past zero. Shared by compressions and "Export By"
+   * conversions, whose tails are equally unmeasurable.
+   */
+  finalizingCompression: string;
+  /**
+   * The compression dropdown row and the applied-value badge, labelled as a QUALITY level;
+   * `{0}` = the percentage of the original quality kept (5..99, lower = stronger compression).
+   */
+  compressActiveLabel: string;
+  /**
+   * Deprecated: the compression rows now read as a quality level via `compressActiveLabel`. Kept
+   * for backward compatibility with hosts that still translate it; no longer shown by the plugin.
+   */
+  compressSmallerByPercent: string;
+  /**
+   * Accessibility suffix for the currently selected row of a menu/dropdown;
+   * `{0}` = the row's label.
+   */
+  selectedOption: string;
+
+  // "Save As" — the preview header's format-conversion menu (images and videos)
+  /**
+   * The preview header's "⋮" overflow button, which holds both output settings (compression and
+   * format conversion). Used as its accessibility label while neither is applied — once one is,
+   * the button announces the applied value via `compressActiveDesc` / `exportActiveDesc` instead.
+   */
+  moreOptions: string;
+  /** The overflow menu's row for format conversion, and its label while none is applied. */
+  exportBy: string;
+  /** Overflow-button accessibility label once a format is applied; `{0}` = format name. */
+  exportActiveDesc: string;
+  /** The menu's first row: send the media in the format it already is. */
+  originalFormat: string;
+  /**
+   * Retained for translation bundles that already carry it. The conversion no longer shows a
+   * static label: it counts the remaining time down with `convertingSecondsLeft`, exactly as a
+   * compression does.
+   */
+  exportingMedia: string;
+  /**
+   * The "Export By" progress overlay — the same single centred countdown line the compression
+   * overlay shows, phrased for a format conversion; `{0}` = whole seconds left. When the encode
+   * outlives its estimate this hands over to `finalizingCompression`, which both jobs share.
+   */
+  convertingSecondsLeft: string;
+  exportFailed: string;
+  /** Result toast; `{0}` = format name. */
+  exportedTo: string;
+  /** Result toast with size; `{0}` = format name, `{1}` = formatted file size. */
+  exportedToFormat: string;
+  /**
+   * Result toast when the target container cannot carry the source's audio codec
+   * (WebM takes only Vorbis/Opus); `{0}` and `{1}` are both the format name.
+   */
+  exportedAudioDropped: string;
+  /** Confirmation body shown before exporting an animated GIF, which flattens it. */
+  convertGifExportMessage: string;
+  /** Confirmation body shown before compressing an animated GIF, which flattens it. */
+  convertGifCompressMessage: string;
+  /** Confirmation title shown before flattening an animated GIF into a still. */
+  convertGifTitle: string;
+  /** Negative button on that confirmation: keep the animated GIF as-is. */
+  keepAnimation: string;
+  /** Positive button on that confirmation: flatten the GIF to a still image. */
+  convertToImage: string;
+
+  clearAppliedFilter: string;
+  toggleAudio: string;
+  trimVideo: string;
+  rotate90Degrees: string;
+  /** Content description of the Crop screen's aspect-ratio button (next to Rotate). */
+  cropAspectRatio: string;
+  /**
+   * Crop aspect-ratio option that locks nothing, letting the crop box take any shape.
+   * The other options are the image's own shape (`aspectRatioOriginal`) and plain numeric
+   * ratios ("1:1", "4:3", …), which are the same in every language and so are not keys.
+   */
+  cropAspectFree: string;
+  noStickersAvailable: string;
+  noEmojisAvailable: string;
+  filterClearLabel: string; // expects {0}
+
+  // Document preview
+  emptyFile: string;
+  previewTruncated: string;
+  unsupportedPreviewKind: string; // expects {0}
+  fileNotPreviewableText: string;
+  couldNotOpenPdf: string; // expects {0}
+  cannotOpenDocumentStream: string;
+  couldNotReadFile: string; // expects {0}
+  webViewUnavailable: string; // expects {0}
+  notDecodableImage: string;
+  couldNotDecodeImage: string; // expects {0}
+  documentPreviewUnavailable: string;
+
+  // Editor Filter Labels
+  filterNone: string;
+  filterAuto: string;
+  filterGray: string;
+  filterNegative: string;
+  filterBright: string;
+  filterContrast: string;
+  filterSharpen: string;
+  filterFilm: string;
+  filterTint: string;
+  filterVignette: string;
+  filterSoft: string;
+  filterDark: string;
+  filterLight: string;
+  filterDesaturate: string;
+  filterEnhance: string;
+  filterCinematic: string;
+  filterBW: string;
+  filterSepia: string;
+  filterVintage: string;
+  filterCool: string;
+  filterWarm: string;
+  filterSaturate: string;
+  filterFade: string;
+  filterVivid: string;
+  filterNormal75: string;
+
+  // Editor Sticker / Emoji Categories
+  categoryClassic: string;
+  categoryFaces: string;
+  categoryLove: string;
+  categoryCelebration: string;
+  categoryAnimals: string;
+  categoryFood: string;
+  categoryVibes: string;
+  categorySmileys: string;
+  categoryPeople: string;
+  categoryAnimalsAndNature: string;
+  categoryFoodAndDrink: string;
+  categoryActivities: string;
+  categoryTravelAndPlaces: string;
+  categoryObjects: string;
+  categorySymbols: string;
+  categoryFlags: string;
+  categoryRecent: string;
+
+  // Upload Service
+  uploadProgressTitle: string;
+  uploadProgressDescription: string;
+  uploadStatusTitle: string;
+  uploadStatusDescription: string;
+  uploadInterruptedTitle: string;
+  uploadInterruptedMessage: string; // expects {0}, {1}
+  uploadRetrying: string; // expects {0}, {1}, {2}, {3}
+  uploadCompletedTitle: string;
+  uploadCompletedMessage: string; // expects {0}
+  uploadFailedTitle: string;
+  uploadFailedMessage: string; // expects {0}, {1}, {2}, {3}
+  uploadingFileProgress: string; // expects {0}, {1}, {2}
+  preparingFilesProgress: string; // expects {0}
+  uploadingMediaTitle: string;
+
+  // Validation
+  validationSelectionLimitNonNegativeInteger: string;
+  validationInitialCameraInvalid: string;
+  validationMediaTypesInvalid: string;
+  validationHoldToRecordDelayInvalid: string;
+  validationMinRecordDurationInvalid: string;
+  validationUrisMustBeArray: string;
+  validationUrisCannotBeEmpty: string;
+  validationTooManyFiles: string; // expects {0}
+  validationInvalidUriAtIndex: string; // expects {0}, {1}
+  validationAlbumNameRequired: string;
+  validationAlbumNameTooLong: string; // expects {0}
+  validationAlbumNameInvalidCharacters: string;
+  validationCaptionMustBeString: string;
+  validationCaptionTooLong: string; // expects {0}
+  validationDelayMustBeNumber: string;
+  validationDelayCannotBeNegative: string;
+  validationDelayTooLong: string; // expects {0}
+  validationStartTimeInvalid: string;
+  validationEndTimeInvalid: string;
+  validationStartBeforeEnd: string;
+  validationTrimDurationTooLong: string; // expects {0}
+  validationUploadUrlRequired: string;
+  validationUploadUrlInvalid: string;
+  validationFileTooLarge: string; // expects {0}, {1}, {2}
+  validationAlbumIdRequired: string;
+  validationAlbumIdTooLong: string; // expects {0}
+  validationDegreesMustBeNumber: string;
+  validationDegreesInvalid: string;
+  validationWidthPositive: string;
+  validationHeightPositive: string;
+  validationXNumber: string;
+  validationYNumber: string;
+  validationFilterTypeInvalid: string; // expects {0}, {1}
+  validationFlashModeInvalid: string; // expects {0}, {1}
+  validationFaceEffectInvalid: string; // expects {0}, {1}
+  validationThemeInvalid: string; // expects {0}, {1}
+
+  // Errors / State (used in React Native side & native side)
+  errorCameraPermission: string;
+  errorPleaseEnableCameraPermission: string;
+  errorMicrophonePermission: string;
+  /** Shown when the mic is declined at record time — the clip is recorded silently, not blocked. */
+  errorMicrophoneDeniedSilentVideo: string;
+  errorStoragePermission: string;
+  /** Shown when the gallery permission is declined; the camera itself stays usable. */
+  errorGalleryPermission: string;
+  errorInvalidUri: string;
+  errorFileNotFound: string;
+  errorFileTooLarge: string;
+  errorOperationCancelled: string;
+  errorCameraUnavailable: string;
+  errorInsufficientStorage: string;
+  /** Refusal shown when a recording is started with too little free space to be worth beginning. */
+  errorStorageFullVideo: string;
+  /** Shown when a recording ends early because the volume filled up. What was recorded is kept. */
+  noticeStorageFullStopped: string;
+  /** Title of the blocking dialog raised when low storage ends a recording in flight. */
+  storageAlmostFullTitle: string;
+  /** Body of that dialog. The clip is already finalized by the time it is shown. */
+  storageAlmostFullMessage: string;
+  /** Title of the blocking dialog raised when low MEMORY ends a recording in flight. */
+  memoryCriticalTitle: string;
+  /** Body of that dialog. The clip is already finalized by the time it is shown. */
+  memoryCriticalMessage: string;
+  /** Sole button on that dialog; advances to the editor with the recorded clip. */
+  next: string;
+  /** Shown when the encoder failed and the clip could not be saved at all. */
+  errorRecordingFailed: string;
+  errorNetworkUnavailable: string;
+  errorUploadFailed: string;
+  /** Shown when a photo/video picked from the gallery can't be opened in the editor. */
+  errorMediaLoadFailed: string;
+  errorUnknown: string;
+  statusReady: string;
+  statusProcessingWithProgress: string; // expects {0}
+  statusProcessing: string;
+  statusSuccess: string;
+  statusUnknown: string;
+
+  // ===== Multilingual coverage additions =====
+  /** Camera flash "auto" label (fixes pre-existing default without interface member). */
+  flashAuto: string;
+  // Generic fallbacks / nouns
+  unknown: string;
+  untitled: string;
+  preview: string;
+  media: string;
+  image: string;
+  video: string;
+  // Library item actions & confirmations
+  deleteConfirmTitle: string;
+  deleteConfirmMessage: string;
+  notSecurelyErasedTitle: string;
+  notSecurelyErasedMessage: string;
+  deleteMedia: string;
+  shareMedia: string;
+  // Editor tools / sheets
+  toolFilter: string;
+  toolCrop: string;
+  toolText: string;
+  toolEmoji: string;
+  toolGrid: string;
+  emoji: string;
+  stickers: string;
+  // Editor GIF picker
+  toolGif: string;
+  gifPickerTitle: string;
+  gifSearchPlaceholder: string;
+  gifTrending: string;
+  gifCategories: string;
+  noGifsFound: string;
+  gifLoadError: string;
+  gifOfflineError: string;
+  gifNotConfigured: string;
+  gifRateLimited: string;
+  gifLoading: string;
+  deleteGif: string;
+  categoryGestures: string;
+  playVideo: string;
+  pauseVideo: string;
+  deleteSticker: string;
+  closeEditor: string;
+  download: string;
+  selectedVideo: string;
+  selectedPhoto: string;
+  removeSelectedItem: string;
+  addMoreMedia: string;
+  compressingPleaseWait: string;
+  compressingEllipsis: string;
+  selectFilterTitle: string;
+  filterAccessibilityLabel: string; // expects {0}
+  closeFilters: string;
+  // Audio recording (demo record-audio screen + FAB)
+  recordAudio: string;
+  browseAudio: string;
+  camera: string;
+  closeActionsMenu: string;
+  openActionsMenu: string;
+  micPermanentlyDenied: string;
+  micPermissionDenied: string;
+  micPermissionRequestFailed: string;
+  failedToStartRecording: string;
+  micPermissionNotGranted: string;
+  recordingTooShort: string;
+  failedToSaveRecording: string;
+  requestingPermission: string;
+  allowMicAccess: string;
+  recordingError: string;
+  tryAgain: string;
+  pausedBadge: string;
+  paused: string;
+  tapToStartRecording: string;
+  discard: string;
+  pause: string;
+  resume: string;
+  savingRecording: string;
+  micRationaleMessage: string;
+  // Document preview (demo)
+  unknownSize: string;
+  noAppToOpenFile: string;
+  couldNotOpenFile: string;
+  pageCountSingular: string; // expects {0}
+  pageCountPlural: string; // expects {0}
+  fileCouldNotBePreviewed: string;
+  noInAppPreview: string;
+  openNamed: string; // expects {0}
+  open: string;
+  opening: string;
+  compressing: string;
+  // Kotlin: capture / upload / office / powerpoint
+  errorProcessPhoto: string;
+  errorCapturePhoto: string;
+  uploadErrorCouldNotOpenStream: string;
+  uploadErrorCouldNotOpenFile: string; // expects {0}
+  uploadErrorServerCode: string; // expects {0}
+  uploadErrorNetwork: string; // expects {0}
+  powerPointPresentationTitle: string;
+  couldNotOpenPresentation: string; // expects {0}
+  couldNotReadPowerPoint: string; // expects {0}
+  couldNotOpenDocument: string; // expects {0}
+  couldNotConvertDocument: string; // expects {0}
+  officeBinaryPreviewNote: string;
+  unableToExtractBinaryText: string;
+  openInOfficeAppNote: string;
+  previewTruncatedRowsCols: string; // expects {0},{1}
+  previewTruncatedRows: string; // expects {0}
+  previewTruncatedChapters: string; // expects {0}
+  previewTruncatedNotice: string;
+  powerPointNoSlides: string;
+  unknownDate: string;
+  aspectRatioOriginal: string;
+  aspectRatioFull: string;
+  aspectRatioOriginalShort: string;
+  gifBadge: string;
+  textFontSample: string;
+  slideNumberLabel: string; // expects {0}
+  docTypePowerpoint: string;
+  docTypeWord: string;
+  docTypeExcel: string;
+  docTypeOffice: string;
+  // Native (Kotlin) strings previously wired to keys absent from this map — now host-overridable
+  compressActiveDesc: string; // expects {0} = quality percent kept (5..99)
+  convertGifMessage: string;
+  convertGifCropMessage: string;
+  couldNotDecodeImageGeneric: string;
+  memoryWarningMessage: string;
+  savingEdits: string;
+  textCancel: string;
+  textFont: string;
+  textAlignment: string;
+  textBackground: string;
+  textDone: string;
+  // GIF picker / overlay (native MediaPreviewEditor). gifNotConfigured, gifRateLimited
+  // and gifLoadError are declared once in the "Editor GIF picker" section above.
+  gifSearchHint: string;
+  addingGif: string;
+  gifLoadFailed: string;
+  gifOffline: string;
+  gifTimeout: string;
+  gifServerError: string;
+  gifNoResults: string;
+  // Media library shell — details sheet, metadata rows and formatting units
+  mediaDetails: string;
+  photoDetails: string;
+  videoDetails: string;
+  metaFileName: string;
+  metaFileType: string;
+  metaFileSize: string;
+  metaDuration: string;
+  metaResolution: string;
+  metaDate: string;
+  metaPath: string;
+  pixelsUnit: string;
+  viewDetails: string;
+  fileTypeGeneric: string;
+  audioTypeGeneric: string;
+  // Full-screen viewer video controls
+  play: string;
+  toggleVideoControls: string;
+  seekBackward: string; // expects {0} = seconds
+  seekForward: string; // expects {0} = seconds
+}
+
+export type CameraTranslationKey = keyof CameraTranslations;
+
+export type CameraTranslationFunction = (
+  key: CameraTranslationKey,
+  ...args: Array<string | number | boolean | null | undefined>
+) => string | undefined | null;
+
+export type CameraTranslationMap = Partial<
+  Record<CameraTranslationKey, string | undefined | null>
+>;
+
+/**
+ * Translations for many languages at once, keyed by language identifier.
+ *
+ * Keys are BCP-47 tags in whatever spelling the host already uses — `fr`,
+ * `pt-BR`, `zh_CN`, `zh-Hant` all work, and lookup is case- and
+ * separator-insensitive. Register the whole set once and switch languages with
+ * {@link setCameraLanguage}.
+ *
+ * ```ts
+ * const bundles: CameraTranslationBundles = {
+ *   fr: { send: 'Envoyer', cancel: 'Annuler' },
+ *   ar: { send: 'إرسال', cancel: 'إلغاء' },
+ * };
+ * ```
+ */
+export type CameraTranslationBundles = Record<string, CameraTranslationMap>;
+
+/**
+ * Whatever a host's `subscribe` happens to hand back. Functions, RN's
+ * `EmitterSubscription` (`remove`), and Rx-style subscriptions (`unsubscribe`)
+ * are all accepted so the provider can usually be a one-line adapter over an
+ * i18n library the host already has; returning nothing is fine too.
+ */
+export type CameraLanguageSubscription =
+  | (() => void)
+  | { remove: () => void }
+  | { unsubscribe: () => void }
+  | null
+  | undefined
+  | void;
+
+/**
+ * A live view of the host app's active language. Bind one once at startup and
+ * every plugin surface — React Native screens *and* the native Android camera —
+ * follows the host from then on, with no further calls on language change.
+ *
+ * The host stays the single source of truth: the plugin only reads this, never
+ * the device locale, and keeps no language state of its own beyond the last
+ * value read here.
+ *
+ * ```ts
+ * configureCameraPlugin({
+ *   language: {
+ *     get: () => i18n.language,
+ *     subscribe: (onChange) => {
+ *       i18n.on('languageChanged', onChange);
+ *       return () => i18n.off('languageChanged', onChange);
+ *     },
+ *   },
+ *   translations: myBundles,
+ * });
+ * ```
+ */
+export interface CameraLanguageProvider {
+  /**
+   * The host's language right now, as a BCP-47 tag. Called on bind and on every
+   * change notification, so it must be cheap and must not throw for a missing
+   * language — return `null`/`''` instead, which means "shipped English".
+   */
+  get(): string | null | undefined;
+  /**
+   * Registers a change listener and returns a way to remove it. The callback may
+   * be handed the new tag (i18next's `languageChanged` does) or called bare, in
+   * which case the plugin re-reads {@link CameraLanguageProvider.get}.
+   *
+   * Return the unsubscriber so a re-bind or teardown can release the listener;
+   * the plugin only ever holds one subscription per provider.
+   */
+  subscribe(
+    callback: (locale?: string | null) => void
+  ): CameraLanguageSubscription;
+}
+
+export interface CameraLocalizationConfig {
+  /**
+   * The host app's currently active language, as a BCP-47 tag (`'fr'`,
+   * `'pt-BR'`, `'zh-Hans'`, `'ar'`). This is the only thing the plugin needs in
+   * order to pick a bundle and decide text direction — there is no language
+   * selector and no language list inside the plugin.
+   *
+   * A bound {@link CameraLocalizationConfig.languageProvider} outranks this: the
+   * provider is re-read after the config is applied, so the two cannot drift.
+   */
+  locale?: string;
+  /**
+   * A live view of the host's language, for one-time automatic synchronization.
+   * Configure it once and the plugin follows every later host language change on
+   * its own — no repeated {@link setCameraLanguage} calls.
+   *
+   * Binding is by object identity, so passing the same provider again re-reads it
+   * without stacking a second listener, and replacing it releases the old
+   * subscription. Pass `null` to detach and go back to manual switching.
+   *
+   * Unlike every other field here, a provider is *not* cleared by an omitted key
+   * in {@link setCameraLocalization} — a binding made once at startup survives a
+   * later config replace.
+   */
+  languageProvider?: CameraLanguageProvider | null;
+  /**
+   * The host's own translate function. Called with a plugin translation key; return
+   * a string to use it, or a falsy value to fall through to `bundles`, then to
+   * English. Errors thrown here are swallowed and treated as "not translated".
+   */
+  translate?: CameraTranslationFunction;
+  /** Overrides for the active language only. Highest priority of all sources. */
+  translations?: CameraTranslationMap;
+  /**
+   * Translations for every language the host supports, keyed by locale. Register
+   * once at startup; from then on a bound
+   * {@link CameraLocalizationConfig.languageProvider} picks the right bundle
+   * automatically, or call {@link setCameraLanguage} on each change manually.
+   */
+  bundles?: CameraTranslationBundles;
+  /** Language used when the active one has no translation for a key. Defaults to `'en'`. */
+  fallbackLocale?: string;
+  /**
+   * Force text direction. Normally omit this: direction is derived from `locale`
+   * (Arabic, Persian, Hebrew, Urdu, … are right-to-left), and falls back to the
+   * app-level `I18nManager.isRTL` when no locale is set.
+   */
+  isRtl?: boolean;
+}
+
+export interface CameraLocalizationProviderProps
+  extends Omit<CameraLocalizationConfig, 'locale'> {
+  children: ReactNode;
+  /**
+   * The host app's active language identifier. Changing it re-renders every
+   * plugin surface and re-pushes translations to the native camera — no restart.
+   *
+   * A non-string value is treated purely as a cache-busting token, which keeps
+   * hosts working that pass a revision number here. Omit it entirely when a
+   * `languageProvider` is bound: the provider is then the authority and this
+   * component needs no re-render to follow a language change.
+   */
+  locale?: string | number;
+  /**
+   * Optional host-controlled invalidation token for non-locale i18n changes.
+   */
+  version?: string | number;
+}
+
+export const defaultTranslations: CameraTranslations = {
+  all: 'All',
+  photos: 'Photos',
+  videos: 'Videos',
+  documents: 'Documents',
+  cancel: 'Cancel',
+  done: 'Done',
+  ok: 'OK',
+  use: 'Use',
+  trim: 'Trim',
+  selectCover: 'Select cover',
+  add: 'Add',
+  addMore: 'Add more',
+  addMorePlus: '+ Add more',
+  mediaCounter: '{0} / {1}',
+  trimRangeLabel: '{0}  –  {1}',
+  durationZero: '0:00',
+  fileSizeBytes: '{0} B',
+  fileSizeKb: '{0} KB',
+  fileSizeMb: '{0} MB',
+  fileSizeGb: '{0} GB',
+  dateFormatPattern: 'MMM dd, yyyy',
+  openSettings: 'Open Settings',
+  close: 'Close',
+  back: 'Back',
+  send: 'Send',
+  save: 'Save',
+  delete: 'Delete',
+  deleteFile: 'Delete file',
+  clear: 'Clear',
+  clearFilter: 'Clear applied filter',
+  filterClearSuffix: '{0} (Clear)',
+  audio: 'Audio',
+  document: 'Document',
+  openingCamera: 'Opening camera...',
+  initializingCamera: 'Initializing camera...',
+  gallery: 'Gallery',
+  selectedCount: '{0} selected',
+  openGallery: 'Open gallery',
+  openWith: 'Open with',
+  libraryEmptyTitle: 'Nothing here yet',
+  libraryEmptyMessage: 'Tap the + button to capture photos and videos with the camera',
+  share: 'Share',
+
+  photoMode: 'Photo',
+  videoMode: 'Video',
+  recording: 'Recording',
+  shutterCapture: 'Capture',
+  shutterHoldToRecord: 'Capture. Hold to record video',
+  holdForVideo: 'Hold for video, tap for photo',
+  slideUpToLock: 'Slide up to lock',
+  slideToCancel: 'Slide to cancel',
+  cancelRecording: 'Cancel',
+  releaseToCancel: 'Release to cancel',
+  recordingLocked: 'Recording locked · Tap to stop',
+  flashOn: 'Flash on',
+  flashOff: 'Flash off',
+  flashAuto: 'Flash auto',
+  switchCamera: 'Switch camera',
+  toggleFlashlight: 'Toggle flashlight',
+  pointCameraAtBarcode: 'Point the camera at a QR code or barcode',
+  closeScanner: 'Close scanner',
+  permissionRequiredTitle: 'Permission required',
+  permissionRequiredMessage:
+    'Camera and media access are needed to use the camera. Please enable the permissions for this app in Settings.',
+  permissionCameraRequiredMessage:
+    'Camera access is needed to use the camera. Please enable it for this app in Settings.',
+  permissionMediaRequiredTitle: 'Gallery access required',
+  permissionMediaRequiredMessage:
+    'Photo and video access is needed to browse your gallery. Please enable it for this app in Settings.',
+  permissionRationaleCameraPersistentMessage:
+    'This app needs camera access to take photos and record video. When the system asks, choose "While using the app" so you are not asked again each time you reopen the app.',
+  permissionContinue: 'Continue',
+  permissionRationaleCameraTitle: 'Camera Permission Required',
+  permissionRationaleCameraMessage:
+    'This app needs camera access to take photos and record videos.',
+  permissionRationaleStorageTitle: 'Storage Permission Required',
+  permissionRationaleStorageMessage:
+    'This app needs storage access to save photos and videos to your gallery.',
+  permissionRationaleMicrophoneTitle: 'Microphone Permission Required',
+  permissionRationaleMicrophoneMessage:
+    'This app needs microphone access to record audio with videos.',
+  permissionGrant: 'Grant',
+  permissionDeny: 'Deny',
+  cameraUnavailable: 'Camera not available on this device',
+  cameraNotFound: 'No camera found. Check device settings.',
+  cameraInitializationFailed: 'Failed to initialize camera. Please try again.',
+  cameraPermissionDenied: 'Camera permission denied',
+  cameraPermissionRequired: 'Camera permission is required to use this feature',
+  tapToScan: 'Tap to scan',
+
+  preparingVideo: 'Preparing video...',
+  selectionTooShort: 'Selection too short',
+  trimming: 'Trimming...',
+  trimFailed: 'Trim failed',
+  cropping: 'Cropping...',
+  cropFailed: 'Crop failed',
+  savingCover: 'Saving cover...',
+  couldNotSetCover: 'Could not set cover',
+  coverUpdated: 'Cover updated',
+  saving: 'Saving...',
+  savedToGallery: 'Saved to gallery',
+  failedToSaveMedia: 'Failed to save media',
+  sending: 'Sending...',
+  failedToSendMedia: 'Failed to send media',
+  couldNotSaveEditsSendingOriginal:
+    'Could not save edits, sending original',
+  sendFailed: 'Send failed',
+  sendFailedWithMessage: 'Send failed: {0}',
+  addTextTitle: 'Add text',
+  addTextButton: 'Add',
+  typeTextHint: 'Type text',
+  sizeLabel: 'Size: {0}',
+  drawOnImage: 'Draw on the image',
+  preparing: 'Preparing...',
+  couldNotPrepareEditsForCropping: 'Could not prepare edits for cropping',
+  useTwoFingersToResizeOrRotate: 'Use two fingers to resize or rotate',
+  operationTimedOut: 'Operation timed out',
+  audioMuted: 'Audio muted',
+  audioOn: 'Audio on',
+  compressVideo: 'Compress Video',
+  originalVideo: 'Original video',
+  compressImage: 'Compress Image',
+  originalImage: 'Original image',
+  compressionProfile: 'Compression',
+  profileRecommended: 'Recommended',
+  compressionAlreadyMinimal:
+    'Already as small as it gets — keeping the original',
+  compressEstimatedSize: '{0} (~{1})',
+  compressOriginalSize: '{0} ({1})',
+  compressSizeRange: '{0} – {1}',
+  compressedToSize: 'Compressed to {0} ({1}% smaller)',
+  compressedToSizeOnly: 'Compressed to {0}',
+  compressionFailed: 'Compression failed',
+  compressingSecondsLeft: 'Compressing ({0}s left)',
+  finalizingCompression: 'Finalizing...',
+  compressActiveLabel: '{0}% quality',
+  compressSmallerByPercent: 'Smaller by {0}%',
+  selectedOption: '{0}, selected',
+
+  moreOptions: 'More options',
+  exportBy: 'Save As',
+  exportActiveDesc: 'Save format: {0}',
+  originalFormat: 'Original',
+  exportingMedia: 'Saving…',
+  convertingSecondsLeft: 'Exporting ({0}s left)',
+  exportFailed: 'Export failed',
+  exportedTo: 'Exported as {0}',
+  exportedToFormat: 'Exported as {0} ({1})',
+  exportedAudioDropped:
+    'Exported as {0} — {1} cannot carry this audio track, so audio was removed',
+  convertGifExportMessage:
+    'Exporting this GIF to another format will remove its animation and save it as a still image.',
+  convertGifCompressMessage:
+    'Compressing this GIF will remove its animation and save it as a still image.',
+  convertGifTitle: 'Convert GIF to image?',
+  keepAnimation: 'Keep animation',
+  convertToImage: 'Convert',
+
+  clearAppliedFilter: 'Clear applied filter',
+  toggleAudio: 'Toggle audio',
+  trimVideo: 'Trim video',
+  rotate90Degrees: 'Rotate 90 degrees',
+  cropAspectRatio: 'Aspect ratio',
+  cropAspectFree: 'Free',
+  noStickersAvailable: 'No stickers available',
+  noEmojisAvailable: 'No emojis available',
+  filterClearLabel: '{0} (Clear)',
+
+  emptyFile: '(empty file)',
+  previewTruncated: 'preview truncated',
+  unsupportedPreviewKind: 'Unsupported preview kind: {0}',
+  fileNotPreviewableText: 'File is not previewable text',
+  couldNotOpenPdf: 'Could not open PDF: {0}',
+  cannotOpenDocumentStream: 'Cannot open document stream',
+  couldNotReadFile: 'Could not read file: {0}',
+  webViewUnavailable: 'WebView unavailable: {0}',
+  notDecodableImage: 'Not a decodable image',
+  couldNotDecodeImage: 'Could not decode image: {0}',
+  documentPreviewUnavailable: 'Document preview unavailable',
+
+  filterNone: 'None',
+  filterAuto: 'Auto',
+  filterGray: 'Gray',
+  filterNegative: 'Negative',
+  filterBright: 'Bright',
+  filterContrast: 'Contrast',
+  filterSharpen: 'Sharpen',
+  filterFilm: 'Film',
+  filterTint: 'Tint',
+  filterVignette: 'Vignette',
+  filterSoft: 'Soft',
+  filterDark: 'Dark',
+  filterLight: 'Light',
+  filterDesaturate: 'Desaturate',
+  filterEnhance: 'Enhance',
+  filterCinematic: 'Cinematic',
+  filterBW: 'B&W',
+  filterSepia: 'Sepia',
+  filterVintage: 'Vintage',
+  filterCool: 'Cool',
+  filterWarm: 'Warm',
+  filterSaturate: 'Saturate',
+  filterFade: 'Fade',
+  filterVivid: 'Vivid',
+  filterNormal75: 'Normal (75%)',
+
+  categoryClassic: 'Classic',
+  categoryFaces: 'Faces',
+  categoryLove: 'Love',
+  categoryCelebration: 'Celebration',
+  categoryAnimals: 'Animals',
+  categoryFood: 'Food',
+  categoryVibes: 'Vibes',
+  categorySmileys: 'Smileys',
+  categoryPeople: 'People',
+  categoryAnimalsAndNature: 'Animals & Nature',
+  categoryFoodAndDrink: 'Food & Drink',
+  categoryActivities: 'Activities',
+  categoryTravelAndPlaces: 'Travel & Places',
+  categoryObjects: 'Objects',
+  categorySymbols: 'Symbols',
+  categoryFlags: 'Flags',
+  categoryRecent: 'Recent',
+
+  uploadProgressTitle: 'Upload Progress',
+  uploadProgressDescription: 'Displays progress of background uploads',
+  uploadStatusTitle: 'Upload Status',
+  uploadStatusDescription:
+    'Notifies when a background upload completes or fails',
+  uploadInterruptedTitle: 'Upload interrupted',
+  uploadInterruptedMessage:
+    'A previous upload stopped before completing (file {0} of {1}).',
+  uploadRetrying: 'Retrying file {0} of {1} (attempt {2} of {3})...',
+  uploadCompletedTitle: 'Upload completed',
+  uploadCompletedMessage: 'Successfully uploaded {0} file(s).',
+  uploadFailedTitle: 'Upload failed',
+  uploadFailedMessage: 'Uploaded {0} of {1} file(s) - {2} failed. {3}',
+  uploadingFileProgress: 'Uploading file {0} of {1} ({2}%)',
+  preparingFilesProgress: 'Preparing files... ({0}%)',
+  uploadingMediaTitle: 'Uploading media',
+
+  validationSelectionLimitNonNegativeInteger:
+    'Selection limit must be a non-negative integer',
+  validationInitialCameraInvalid:
+    'Initial camera must be either "back" or "front"',
+  validationMediaTypesInvalid:
+    'Media type must be one of: "all", "photo", "video"',
+  validationHoldToRecordDelayInvalid:
+    'Hold-to-record delay must be a non-negative number of milliseconds (0 = system long-press timeout)',
+  validationMinRecordDurationInvalid:
+    'Minimum recording duration must be a non-negative number of milliseconds',
+  validationUrisMustBeArray: 'Media URIs must be an array',
+  validationUrisCannotBeEmpty: 'Media URIs cannot be empty',
+  validationTooManyFiles: 'Cannot process more than {0} files at once',
+  validationInvalidUriAtIndex: 'Invalid URI at index {0}: {1}',
+  validationAlbumNameRequired: 'Album name must be a non-empty string',
+  validationAlbumNameTooLong: 'Album name cannot exceed {0} characters',
+  validationAlbumNameInvalidCharacters:
+    'Album name contains invalid characters: / : * ? " < > |',
+  validationCaptionMustBeString: 'Caption must be a string',
+  validationCaptionTooLong: 'Caption cannot exceed {0} characters',
+  validationDelayMustBeNumber: 'Delay must be a valid number',
+  validationDelayCannotBeNegative: 'Delay cannot be negative',
+  validationDelayTooLong: 'Delay cannot exceed {0} seconds',
+  validationStartTimeInvalid: 'Start time must be a non-negative number',
+  validationEndTimeInvalid: 'End time must be a non-negative number',
+  validationStartBeforeEnd: 'Start time must be less than end time',
+  validationTrimDurationTooLong:
+    'Trim duration cannot exceed {0} seconds',
+  validationUploadUrlRequired: 'Upload URL must be a non-empty string',
+  validationUploadUrlInvalid: 'Upload URL must be a valid URL',
+  validationFileTooLarge:
+    '{0} is too large ({1}MB). Maximum allowed size is {2}MB',
+  validationAlbumIdRequired: 'Album ID must be a non-empty string',
+  validationAlbumIdTooLong: 'Album ID cannot exceed {0} characters',
+  validationDegreesMustBeNumber: 'Degrees must be a valid number',
+  validationDegreesInvalid: 'Degrees must be one of: 0, 90, 180, 270',
+  validationWidthPositive: 'Width must be a positive number',
+  validationHeightPositive: 'Height must be a positive number',
+  validationXNumber: 'X coordinate must be a number',
+  validationYNumber: 'Y coordinate must be a number',
+  validationFilterTypeInvalid: 'Invalid filter type: {0}. Valid options: {1}',
+  validationFlashModeInvalid: 'Invalid flash mode: {0}. Valid options: {1}',
+  validationFaceEffectInvalid: 'Invalid face effect: {0}. Valid options: {1}',
+  validationThemeInvalid: 'Invalid camera theme: {0}. Valid options: {1}',
+
+  errorCameraPermission: 'Camera permission is required to use this feature',
+  errorPleaseEnableCameraPermission:
+    'Please enable camera permission in settings',
+  errorMicrophonePermission:
+    'Microphone permission is required for video recording',
+  errorMicrophoneDeniedSilentVideo:
+    'Microphone access denied — this video will be recorded without sound',
+  errorStoragePermission: 'Storage permission is required to save media',
+  errorGalleryPermission: 'Gallery permission is required to browse your media',
+  errorInvalidUri: 'Invalid media file',
+  errorFileNotFound: 'Media file not found',
+  errorFileTooLarge: 'File is too large to process',
+  errorOperationCancelled: 'Operation was cancelled',
+  errorCameraUnavailable: 'Camera is not available on this device',
+  errorInsufficientStorage: 'Not enough storage space available',
+  errorStorageFullVideo: 'Not enough storage space to record a video.',
+  noticeStorageFullStopped: 'Storage is full — recording stopped.',
+  storageAlmostFullTitle: 'Storage almost full',
+  storageAlmostFullMessage:
+    'Storage space is almost full. The current recording will be finalized to prevent data loss.',
+  memoryCriticalTitle: 'Low memory',
+  memoryCriticalMessage:
+    'Your device is running critically low on memory. The current recording will be finalized to prevent crashes or data loss.',
+  next: 'Next',
+  errorRecordingFailed: 'Recording could not be saved. Please try again.',
+  errorNetworkUnavailable: 'Network connection is required',
+  errorUploadFailed: 'Failed to upload media',
+  errorMediaLoadFailed: 'Unable to open the selected media',
+  errorUnknown: 'An error occurred',
+
+  statusReady: 'Ready',
+  statusProcessingWithProgress: 'Processing... {0}%',
+  statusProcessing: 'Processing...',
+  statusSuccess: 'Completed successfully',
+  statusUnknown: 'Unknown status',
+
+  // ===== Multilingual coverage additions =====
+  unknown: 'Unknown',
+  untitled: 'Untitled',
+  preview: 'Preview',
+  media: 'Media',
+  image: 'Image',
+  video: 'Video',
+  deleteConfirmTitle: 'Delete this item?',
+  deleteConfirmMessage:
+    'Are you sure you want to delete this item? This action cannot be undone.',
+  notSecurelyErasedTitle: 'Removed, but not securely erased',
+  notSecurelyErasedMessage:
+    'This item was removed from your library, but its file data could not be fully overwritten. It may still be recoverable from device storage.',
+  deleteMedia: 'Delete media',
+  shareMedia: 'Share media',
+  toolFilter: 'Filter',
+  toolCrop: 'Crop',
+  toolText: 'Text',
+  toolEmoji: 'Emoji',
+  toolGrid: 'Grid',
+  emoji: 'Emoji',
+  stickers: 'Stickers',
+  toolGif: 'GIF',
+  gifPickerTitle: 'Add GIF',
+  gifSearchPlaceholder: 'Search GIFs',
+  gifTrending: 'Trending',
+  gifCategories: 'Categories',
+  noGifsFound: 'No GIFs found',
+  gifLoadError: "Couldn't load GIFs",
+  gifOfflineError: 'No internet connection',
+  gifNotConfigured: 'GIF picker is not set up',
+  gifRateLimited: 'Too many requests. Try again shortly.',
+  gifLoading: 'Loading GIFs…',
+  deleteGif: 'Delete GIF',
+  categoryGestures: 'Gestures',
+  playVideo: 'Play video',
+  pauseVideo: 'Pause video',
+  deleteSticker: 'Delete sticker',
+  closeEditor: 'Close editor',
+  download: 'Download',
+  selectedVideo: 'Selected video',
+  selectedPhoto: 'Selected photo',
+  removeSelectedItem: 'Remove selected item',
+  addMoreMedia: 'Add more media',
+  compressingPleaseWait: 'Compressing, please wait',
+  compressingEllipsis: 'Compressing…',
+  selectFilterTitle: 'Select Filter',
+  filterAccessibilityLabel: '{0} filter',
+  closeFilters: 'Close filters',
+  recordAudio: 'Record Audio',
+  browseAudio: 'Browse Audio',
+  camera: 'Camera',
+  closeActionsMenu: 'Close actions menu',
+  openActionsMenu: 'Open actions menu',
+  micPermanentlyDenied:
+    'Microphone permission permanently denied. Please enable it in Settings.',
+  micPermissionDenied: 'Microphone permission denied.',
+  micPermissionRequestFailed: 'Failed to request microphone permission.',
+  failedToStartRecording: 'Failed to start recording',
+  micPermissionNotGranted: 'Microphone permission not granted.',
+  recordingTooShort: 'Recording too short. Hold for at least 0.5 seconds.',
+  failedToSaveRecording: 'Failed to save recording',
+  requestingPermission: 'Requesting Permission',
+  allowMicAccess: 'Please allow microphone access to record audio.',
+  recordingError: 'Recording Error',
+  tryAgain: 'Try Again',
+  pausedBadge: 'PAUSED',
+  paused: 'Paused',
+  tapToStartRecording: 'Tap the button below to start recording',
+  discard: 'Discard',
+  pause: 'Pause',
+  resume: 'Resume',
+  savingRecording: 'Saving recording…',
+  micRationaleMessage: 'This app needs microphone access to record audio.',
+  unknownSize: 'Unknown size',
+  noAppToOpenFile: 'No app available to open this file.',
+  couldNotOpenFile: 'Could not open this file.',
+  pageCountSingular: '{0} page',
+  pageCountPlural: '{0} pages',
+  fileCouldNotBePreviewed: 'This file could not be previewed.',
+  noInAppPreview: 'No in-app preview for this format.',
+  openNamed: 'Open {0}',
+  open: 'Open',
+  opening: 'Opening…',
+  compressing: 'Compressing...',
+  errorProcessPhoto: 'Failed to process captured photo.',
+  errorCapturePhoto: 'Failed to capture photo. Please try again.',
+  uploadErrorCouldNotOpenStream: 'Could not open the file to upload',
+  uploadErrorCouldNotOpenFile: 'Could not open file: {0}',
+  uploadErrorServerCode: 'Server returned error code: {0}',
+  uploadErrorNetwork: 'Network error: {0}',
+  powerPointPresentationTitle: 'PowerPoint presentation',
+  couldNotOpenPresentation: 'Could not open presentation: {0}',
+  couldNotReadPowerPoint: 'Could not read PowerPoint presentation: {0}',
+  couldNotOpenDocument: 'Could not open document: {0}',
+  couldNotConvertDocument: 'Could not convert document: {0}',
+  officeBinaryPreviewNote:
+    'Text preview shown below — open in PowerPoint, Google Slides, or WPS Office for full formatting and images.',
+  unableToExtractBinaryText:
+    'Unable to extract text from this binary file. Open in PowerPoint for the best experience.',
+  openInOfficeAppNote:
+    'Open this file in PowerPoint, Google Slides, or WPS Office for the best viewing experience.',
+  previewTruncatedRowsCols:
+    'Preview truncated — showing first {0} rows / {1} columns',
+  previewTruncatedRows: 'Preview truncated — showing first {0} rows',
+  previewTruncatedChapters: 'Preview truncated — first {0} chapters',
+  previewTruncatedNotice: 'Preview truncated',
+  powerPointNoSlides: 'No slides',
+  unknownDate: 'Unknown date',
+  aspectRatioOriginal: 'Original',
+  aspectRatioFull: 'Full',
+  aspectRatioOriginalShort: 'Original',
+  gifBadge: 'GIF',
+  textFontSample: 'Aa',
+  slideNumberLabel: 'SLIDE {0}',
+  docTypePowerpoint: 'PowerPoint Presentation',
+  docTypeWord: 'Word Document',
+  docTypeExcel: 'Excel Spreadsheet',
+  docTypeOffice: 'Office Document',
+  compressActiveDesc: 'Quality: {0}%',
+  convertGifMessage:
+    'Editing this GIF will remove its animation and save it as a still image.',
+  convertGifCropMessage:
+    'Cropping this GIF will remove its animation and save it as a still image.',
+  couldNotDecodeImageGeneric: 'Could not decode image',
+  memoryWarningMessage:
+    'Low memory detected. Background operations are being reduced to keep recording stable.',
+  savingEdits: 'Saving edits...',
+  textCancel: 'Cancel text',
+  textFont: 'Change font',
+  textAlignment: 'Change text alignment',
+  textBackground: 'Change text background',
+  textDone: 'Apply text',
+  // GIF picker / overlay (native MediaPreviewEditor). gifNotConfigured, gifRateLimited
+  // and gifLoadError already have defaults in the "Editor GIF picker" section above.
+  gifSearchHint: 'Search GIFs',
+  addingGif: 'Adding GIF…',
+  gifLoadFailed: "Couldn't load that GIF",
+  gifOffline: 'No internet connection',
+  gifTimeout: 'The request timed out',
+  gifServerError: 'The GIF service is unavailable',
+  gifNoResults: 'No GIFs found',
+  // Media library shell — details sheet, metadata rows and formatting units
+  mediaDetails: 'Media details',
+  photoDetails: 'Photo details',
+  videoDetails: 'Video details',
+  metaFileName: 'File name',
+  metaFileType: 'File type',
+  metaFileSize: 'File size',
+  metaDuration: 'Duration',
+  metaResolution: 'Resolution',
+  metaDate: 'Date',
+  metaPath: 'Path',
+  pixelsUnit: 'px',
+  viewDetails: 'View details',
+  fileTypeGeneric: 'FILE',
+  audioTypeGeneric: 'AUD',
+  // Full-screen viewer video controls
+  play: 'Play',
+  toggleVideoControls: 'Toggle video controls',
+  seekBackward: 'Rewind {0} seconds',
+  seekForward: 'Forward {0} seconds',
+};
+
+export const cameraLocalizationKeys = Object.freeze(
+  Object.keys(defaultTranslations) as CameraTranslationKey[]
+);
+
+function normalizeTranslations(
+  translations?: CameraTranslationMap
+): Partial<CameraTranslations> {
+  if (!translations) return {};
+
+  return cameraLocalizationKeys.reduce<Partial<CameraTranslations>>(
+    (acc, key) => {
+      const value = translations[key];
+      if (typeof value === 'string' && value.length > 0) {
+        acc[key] = value;
+      }
+      return acc;
+    },
+    {}
+  );
+}
+
+function formatMessage(
+  message: string,
+  args: Array<string | number | boolean | null | undefined>
+): string {
+  return args.reduce<string>(
+    (text, arg, index) =>
+      text.split(`{${index}}`).join(arg == null ? '' : String(arg)),
+    message
+  );
+}
+
+function resolveIsRtl(isRtl?: boolean, locale?: string): boolean {
+  // Precedence: an explicit override, then the direction implied by the active
+  // language, then whatever direction the host app itself is running in.
+  if (typeof isRtl === 'boolean') return isRtl;
+  if (locale && normalizeLocale(locale).length > 0) return isRtlLocale(locale);
+  return I18nManager.isRTL;
+}
+
+/**
+ * Normalizes whatever a host's `subscribe` returned into a plain unsubscriber.
+ *
+ * Returning `undefined` for an unrecognized shape is deliberate: the binding
+ * still works, it simply cannot be released — better than calling an arbitrary
+ * method on a host object and guessing wrong.
+ */
+function toLanguageUnsubscribe(
+  subscription: CameraLanguageSubscription
+): (() => void) | undefined {
+  if (typeof subscription === 'function') return subscription;
+  if (typeof subscription !== 'object' || subscription === null) return undefined;
+
+  const remove = (subscription as { remove?: unknown }).remove;
+  if (typeof remove === 'function') {
+    return () => (remove as () => void).call(subscription);
+  }
+
+  const unsubscribe = (subscription as { unsubscribe?: unknown }).unsubscribe;
+  if (typeof unsubscribe === 'function') {
+    return () => (unsubscribe as () => void).call(subscription);
+  }
+
+  return undefined;
+}
+
+/**
+ * True when a value looks like a {@link CameraLanguageProvider} rather than a
+ * language tag. Lets a single `language` option accept either one.
+ */
+export function isCameraLanguageProvider(
+  value: unknown
+): value is CameraLanguageProvider {
+  if (typeof value !== 'object' || value === null) return false;
+  const candidate = value as Partial<CameraLanguageProvider>;
+  return (
+    typeof candidate.get === 'function' && typeof candidate.subscribe === 'function'
+  );
+}
+
+class LocalizationManagerImpl {
+  private translateFn?: CameraTranslationFunction;
+  private hostTranslations?: CameraTranslationMap;
+  private bundles: CameraTranslationBundles = {};
+  private fallbackLocale: string = DEFAULT_LOCALE;
+  private locale = '';
+  private explicitIsRtl?: boolean;
+  private translations: CameraTranslations = { ...defaultTranslations };
+  private isRtl = resolveIsRtl();
+  private listeners = new Set<() => void>();
+  /**
+   * The host's language authority, when one is bound. Held by identity so a
+   * re-bind of the same object is recognized as a no-op.
+   */
+  private languageProvider?: CameraLanguageProvider;
+  /** Releases {@link languageProvider}'s subscription. One at a time, always. */
+  private releaseProviderSubscription?: () => void;
+
+  /**
+   * Binds the host app's language provider — the plugin's language authority for
+   * as long as it stays bound.
+   *
+   * Leak- and duplicate-safe by construction: the previous subscription is always
+   * released before a new one is taken, and re-binding the *same* provider object
+   * only re-reads it, so a startup path that runs more than once (Fast Refresh, a
+   * remount, a second `configureCameraPlugin`) cannot stack listeners.
+   *
+   * @param options.resolve `false` for callers that are about to
+   *   {@link LocalizationManagerImpl.resolve} anyway, keeping a config change to a
+   *   single re-render and a single native push.
+   */
+  public bindLanguageProvider(
+    provider?: CameraLanguageProvider | null,
+    options: { resolve?: boolean } = {}
+  ): void {
+    const shouldResolve = options.resolve !== false;
+
+    if (provider && provider === this.languageProvider) {
+      // Already bound: adopt whatever it reads now, in case the host changed
+      // language through a path that does not notify.
+      if (this.adoptProviderLocale() && shouldResolve) this.resolve();
+      return;
+    }
+
+    this.releaseLanguageProvider();
+    if (!provider) return;
+
+    this.languageProvider = provider;
+
+    // Adopt the CURRENT language before subscribing, so a provider bound at
+    // startup takes effect without waiting for a first change event, and so a
+    // provider that notifies synchronously on subscribe finds state in place.
+    const changed = this.adoptProviderLocale();
+
+    let subscription: CameraLanguageSubscription;
+    try {
+      subscription = provider.subscribe((next) => {
+        this.handleProviderLanguageChange(next);
+      });
+    } catch {
+      // A provider that cannot be subscribed to still drives the language it
+      // reported above; it just will not push later changes.
+      subscription = undefined;
+    }
+    this.releaseProviderSubscription = toLanguageUnsubscribe(subscription);
+
+    if (changed && shouldResolve) this.resolve();
+  }
+
+  /** Detaches the bound provider, if any. The active language is left as-is. */
+  public unbindLanguageProvider(): void {
+    this.releaseLanguageProvider();
+  }
+
+  /**
+   * Re-reads the bound provider and republishes if its language moved. The manual
+   * escape hatch for a host whose provider cannot notify.
+   */
+  public syncLanguageFromProvider(): void {
+    if (!this.languageProvider) return;
+    if (this.adoptProviderLocale()) this.resolve();
+  }
+
+  /** The bound provider, for hosts that need to check whether auto-sync is on. */
+  public getLanguageProvider(): CameraLanguageProvider | undefined {
+    return this.languageProvider;
+  }
+
+  private releaseLanguageProvider(): void {
+    const release = this.releaseProviderSubscription;
+    this.releaseProviderSubscription = undefined;
+    this.languageProvider = undefined;
+    if (!release) return;
+    try {
+      release();
+    } catch {
+      // Teardown is host-owned; a throwing unsubscriber must not break re-binding.
+    }
+  }
+
+  private readProviderLocale(): string | null | undefined {
+    try {
+      return this.languageProvider?.get();
+    } catch {
+      // A throwing `get()` must not silently drop the plugin back to English.
+      return this.locale;
+    }
+  }
+
+  /**
+   * Pulls the provider's language into `locale`. Returns whether it moved, which
+   * is what lets callers skip a redundant re-render and native push.
+   */
+  private adoptProviderLocale(): boolean {
+    const next = normalizeLocale(this.readProviderLocale());
+    if (next === this.locale) return false;
+    this.locale = next;
+    return true;
+  }
+
+  private handleProviderLanguageChange(next?: string | null): void {
+    // The tag may arrive with the notification (i18next passes `lng`) or not at
+    // all, in which case `get()` is the authority.
+    const reported = typeof next === 'string' ? next : this.readProviderLocale();
+    const normalized = normalizeLocale(reported);
+    if (normalized === this.locale) return;
+    this.locale = normalized;
+    this.resolve();
+  }
+
+  /**
+   * Re-asserts a bound provider's language over any `locale` a config carried, so
+   * the host stays the single source of truth even when the two disagree.
+   */
+  private assertLanguageAuthority(): void {
+    if (this.languageProvider) this.adoptProviderLocale();
+  }
+
+  /**
+   * Replaces the whole localization configuration. Anything omitted is cleared,
+   * which is what makes `setCameraLocalization({})` a reset.
+   *
+   * A bound language provider is the one exception: it is only touched when the
+   * config actually carries a `languageProvider` key. Otherwise a screen that
+   * pushes its own bundles would silently switch off auto-sync that was set up at
+   * startup. Pass `languageProvider: null` to detach on purpose.
+   */
+  public setLocalization(config: CameraLocalizationConfig = {}) {
+    this.translateFn = config.translate;
+    this.hostTranslations = config.translations;
+    this.bundles = config.bundles ? { ...config.bundles } : {};
+    this.fallbackLocale = normalizeLocale(config.fallbackLocale) || DEFAULT_LOCALE;
+    this.locale = normalizeLocale(config.locale);
+    this.explicitIsRtl = config.isRtl;
+
+    if ('languageProvider' in config) {
+      this.bindLanguageProvider(config.languageProvider, { resolve: false });
+    }
+    this.assertLanguageAuthority();
+
+    this.resolve();
+  }
+
+  /**
+   * Merges a partial configuration into the current one. Use this to add bundles
+   * or change the language without re-sending everything else.
+   */
+  public updateLocalization(config: CameraLocalizationConfig = {}) {
+    if ('translate' in config) this.translateFn = config.translate;
+    if ('translations' in config) this.hostTranslations = config.translations;
+    if (config.bundles) this.bundles = { ...this.bundles, ...config.bundles };
+    if (config.fallbackLocale !== undefined) {
+      this.fallbackLocale = normalizeLocale(config.fallbackLocale) || DEFAULT_LOCALE;
+    }
+    if (config.locale !== undefined) this.locale = normalizeLocale(config.locale);
+    if ('isRtl' in config) this.explicitIsRtl = config.isRtl;
+
+    if ('languageProvider' in config) {
+      this.bindLanguageProvider(config.languageProvider, { resolve: false });
+    }
+    this.assertLanguageAuthority();
+
+    this.resolve();
+  }
+
+  /**
+   * Switches the active language, keeping registered bundles and callbacks.
+   *
+   * Remains available as a manual fallback while a provider is bound; the next
+   * change the provider reports simply wins, since the host owns the language.
+   */
+  public setLanguage(locale?: string | null): void {
+    this.locale = normalizeLocale(locale);
+    this.resolve();
+  }
+
+  /**
+   * Rebuilds the resolved translation table and text direction, pushes both to
+   * the native camera, and notifies every subscribed component.
+   *
+   * Priority, lowest to highest: shipped English defaults, locale bundles along
+   * the fallback chain, the host's translate callback, then explicit overrides.
+   */
+  private resolve(): void {
+    this.isRtl = resolveIsRtl(this.explicitIsRtl, this.locale);
+
+    const bundleTranslations = normalizeTranslations(
+      resolveLocaleTranslations<CameraTranslationMap>(
+        this.locale,
+        this.bundles,
+        this.fallbackLocale
+      )
+    );
+
+    const generatedTranslations: Partial<CameraTranslations> = {};
+    if (this.translateFn) {
+      cameraLocalizationKeys.forEach((key) => {
+        try {
+          const translated = this.translateFn?.(key);
+          if (typeof translated === 'string' && translated.length > 0) {
+            generatedTranslations[key] = translated;
+          }
+        } catch {
+          // Translation callbacks are host-owned; missing keys fall back below.
+        }
+      });
+    }
+
+    this.translations = {
+      ...defaultTranslations,
+      ...bundleTranslations,
+      ...generatedTranslations,
+      ...normalizeTranslations(this.hostTranslations),
+    };
+
+    try {
+      NativeModules.CustomCamera?.setLocalization?.(
+        this.translations,
+        this.isRtl,
+        this.locale
+      );
+    } catch {
+      // Native localization is best-effort for test, web, and non-Android contexts.
+    }
+
+    this.notifyListeners();
+  }
+
+  public subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  public getString(
+    key: CameraTranslationKey,
+    ...args: Array<string | number | boolean | null | undefined>
+  ): string {
+    let text: string | undefined | null;
+
+    if (this.translateFn) {
+      try {
+        text = this.translateFn(key, ...args);
+      } catch {
+        text = undefined;
+      }
+    }
+
+    const message =
+      typeof text === 'string' && text.length > 0
+        ? text
+        : this.translations[key] || defaultTranslations[key] || String(key);
+
+    return formatMessage(message, args);
+  }
+
+  public getIsRtl(): boolean {
+    return this.isRtl;
+  }
+
+  /** The active language, or `''` when the host has not set one. */
+  public getLocale(): string {
+    return this.locale;
+  }
+
+  /** The language used to fill gaps in the active one. `'en'` unless changed. */
+  public getFallbackLocale(): string {
+    return this.fallbackLocale;
+  }
+
+  /** Every locale the host has registered a bundle for. */
+  public getAvailableLocales(): string[] {
+    return Object.keys(this.bundles);
+  }
+
+  public getTextAlign(): 'left' | 'right' {
+    return this.isRtl ? 'right' : 'left';
+  }
+
+  public getFlexDirection(): 'row' | 'row-reverse' {
+    return this.isRtl ? 'row-reverse' : 'row';
+  }
+
+  public getTranslations(): CameraTranslations {
+    return this.translations;
+  }
+
+  private notifyListeners(): void {
+    this.listeners.forEach((listener) => listener());
+  }
+}
+
+export const LocalizationManager = new LocalizationManagerImpl();
+
+/**
+ * Hands the host app's language and translations to the plugin. This is the
+ * single integration point — call it once at startup, and either bind a
+ * `languageProvider` so later switches are picked up automatically or call
+ * {@link setCameraLanguage} on each change.
+ *
+ * ```ts
+ * setCameraLocalization({
+ *   bundles: myBundles,
+ *   // Bound once; every later host language change follows automatically.
+ *   languageProvider: {
+ *     get: () => i18n.language,
+ *     subscribe: (onChange) => {
+ *       i18n.on('languageChanged', onChange);
+ *       return () => i18n.off('languageChanged', onChange);
+ *     },
+ *   },
+ *   translate: (key) => i18n.t(`camera.${key}`),
+ * });
+ * ```
+ *
+ * Every field is optional and omitted fields are cleared, so `{}` restores the
+ * shipped English strings — with one deliberate exception: a language provider
+ * bound by {@link setCameraLanguageProvider} is kept unless the config explicitly
+ * carries `languageProvider`, so automatic synchronization set up once at startup
+ * cannot be switched off by a later config push.
+ */
+export function setCameraLocalization(
+  config: CameraLocalizationConfig = {}
+): void {
+  LocalizationManager.setLocalization(config);
+}
+
+/**
+ * Merges into the current configuration instead of replacing it. Handy for
+ * registering more bundles later, or changing one field on its own.
+ */
+export function updateCameraLocalization(
+  config: CameraLocalizationConfig = {}
+): void {
+  LocalizationManager.updateLocalization(config);
+}
+
+/**
+ * Turns on one-time automatic language synchronization: bind the host app's
+ * language once and every plugin surface follows it from then on.
+ *
+ * On each host language change the plugin re-resolves its translation table,
+ * re-renders every React Native screen and component, and pushes the new
+ * translations, locale, and RTL direction across the bridge to the native Android
+ * camera and editor — no further calls needed.
+ *
+ * Safe to call more than once: the same provider object re-binds without stacking
+ * a listener, a different one releases the previous subscription first, and `null`
+ * detaches (after which {@link setCameraLanguage} is the way to switch).
+ *
+ * ```ts
+ * // i18next
+ * setCameraLanguageProvider({
+ *   get: () => i18n.language,
+ *   subscribe: (onChange) => {
+ *     i18n.on('languageChanged', onChange);
+ *     return () => i18n.off('languageChanged', onChange);
+ *   },
+ * });
+ *
+ * // a plain store / context
+ * setCameraLanguageProvider({
+ *   get: () => store.getState().language,
+ *   subscribe: (onChange) => store.subscribe(onChange),
+ * });
+ * ```
+ */
+export function setCameraLanguageProvider(
+  provider?: CameraLanguageProvider | null
+): void {
+  LocalizationManager.bindLanguageProvider(provider);
+}
+
+/** Turns automatic synchronization back off. The active language is kept. */
+export function clearCameraLanguageProvider(): void {
+  LocalizationManager.unbindLanguageProvider();
+}
+
+/**
+ * Re-reads the bound language provider and republishes if it moved. Only needed
+ * for a host whose language can change without notifying — normally the
+ * subscription covers this.
+ */
+export function syncCameraLanguage(): void {
+  LocalizationManager.syncLanguageFromProvider();
+}
+
+/** The bound language provider, or `undefined` when auto-sync is off. */
+export function getCameraLanguageProvider(): CameraLanguageProvider | undefined {
+  return LocalizationManager.getLanguageProvider();
+}
+
+/**
+ * Switches the plugin to the host's newly selected language — the manual
+ * alternative to {@link setCameraLanguageProvider}, and still supported.
+ *
+ * Registered bundles and the host's translate callback are kept, so this is the
+ * one call to make from a language-change handler. Text direction is re-derived
+ * from the tag, so Arabic and Persian flip the plugin to RTL automatically. Open
+ * plugin screens and the native camera update immediately — no restart.
+ *
+ * ```ts
+ * i18n.on('languageChanged', setCameraLanguage);
+ * ```
+ */
+export function setCameraLanguage(
+  locale?: string | null | CameraLanguageProvider
+): void {
+  // Accepting a provider here too means a host that reaches for the familiar
+  // function gets automatic synchronization instead of a mangled language tag.
+  if (isCameraLanguageProvider(locale)) {
+    LocalizationManager.bindLanguageProvider(locale);
+    return;
+  }
+  LocalizationManager.setLanguage(locale);
+}
+
+/** Registers (or replaces) translations for one or more languages. */
+export function registerCameraTranslations(
+  bundles: CameraTranslationBundles
+): void {
+  LocalizationManager.updateLocalization({ bundles });
+}
+
+/** The plugin's active language, or `''` when the host has not set one. */
+export function getCameraLocale(): string {
+  return LocalizationManager.getLocale();
+}
+
+/** Whether plugin UI is currently laid out right-to-left. */
+export function getCameraIsRtl(): boolean {
+  return LocalizationManager.getIsRtl();
+}
+
+type CameraLocalizationContextValue = ReturnType<typeof useCameraLocalization>;
+
+const CameraLocalizationContext =
+  createContext<CameraLocalizationContextValue | null>(null);
+
+export function CameraLocalizationProvider({
+  children,
+  translate,
+  translations,
+  bundles,
+  fallbackLocale,
+  isRtl,
+  locale,
+  languageProvider,
+  version,
+}: CameraLocalizationProviderProps) {
+  useEffect(() => {
+    setCameraLocalization({
+      // A non-string `locale` is a legacy cache-busting token, not a language tag.
+      locale: typeof locale === 'string' ? locale : undefined,
+      translate,
+      translations,
+      bundles,
+      fallbackLocale,
+      isRtl,
+      // Spread rather than always passing the key: an absent prop must leave a
+      // provider bound elsewhere (at startup) alone, while `null` still detaches.
+      ...(languageProvider === undefined ? null : { languageProvider }),
+    });
+  }, [
+    translate,
+    translations,
+    bundles,
+    fallbackLocale,
+    isRtl,
+    locale,
+    languageProvider,
+    version,
+  ]);
+
+  const value = useCameraLocalization();
+
+  return React.createElement(
+    CameraLocalizationContext.Provider,
+    { value },
+    children
+  );
+}
+
+export function useCameraLocalization() {
+  const [revision, setRevision] = useState(0);
+
+  useEffect(() => {
+    return LocalizationManager.subscribe(() => {
+      setRevision((tick) => tick + 1);
+    });
+  }, []);
+
+  return useMemo(() => {
+    const isRtl = LocalizationManager.getIsRtl();
+    return {
+      t: (
+        key: CameraTranslationKey,
+        ...args: Array<string | number | boolean | null | undefined>
+      ) => LocalizationManager.getString(key, ...args),
+      /** The host's active language, or `''` when it has not set one. */
+      locale: LocalizationManager.getLocale(),
+      isRtl,
+      direction: isRtl ? 'rtl' : 'ltr',
+      textAlign: LocalizationManager.getTextAlign(),
+      flexDirection: LocalizationManager.getFlexDirection(),
+      rtlStyle: <T extends object>(ltr: T, rtl: T): T => (isRtl ? rtl : ltr),
+      writingDirectionStyle: {
+        writingDirection: isRtl ? 'rtl' : 'ltr',
+        textAlign: isRtl ? 'right' : 'left',
+      } as const,
+      layoutDirectionStyle: {
+        direction: isRtl ? 'rtl' : 'ltr',
+      } as const,
+      /** Row/text styles that follow the active language's direction. */
+      styles: isRtl ? rtlDirectionalStyles.rtl : rtlDirectionalStyles.ltr,
+      translations: LocalizationManager.getTranslations(),
+    };
+  }, [revision]);
+}
+
+export function useCameraLocalizationContext() {
+  const context = useContext(CameraLocalizationContext);
+  const fallback = useCameraLocalization();
+  return context ?? fallback;
+}
+
+/**
+ * Both directions, created up front. `StyleSheet.create` runs once at module
+ * load, so the only way to stay correct across a live language switch is to
+ * build both variants and choose between them at read time.
+ */
+const rtlDirectionalStyles = {
+  ltr: StyleSheet.create({
+    row: { flexDirection: 'row' },
+    text: { writingDirection: 'ltr', textAlign: 'left' },
+  }),
+  rtl: StyleSheet.create({
+    row: { flexDirection: 'row-reverse' },
+    text: { writingDirection: 'rtl', textAlign: 'right' },
+  }),
+} as const;
+
+/** Row/text styles for the active language. Prefer the hook inside components. */
+export function getRtlAwareStyles(): { row: ViewStyle; text: TextStyle } {
+  return LocalizationManager.getIsRtl()
+    ? rtlDirectionalStyles.rtl
+    : rtlDirectionalStyles.ltr;
+}
+
+/**
+ * Direction-aware styles that re-read the active language on every access.
+ *
+ * Defined with getters rather than a plain object: the language can change at
+ * any time, and a value captured at module load would keep an Arabic UI
+ * left-to-right until the app restarted.
+ */
+export const rtlAwareStyles: { readonly row: ViewStyle; readonly text: TextStyle } =
+  {
+    get row() {
+      return getRtlAwareStyles().row;
+    },
+    get text() {
+      return getRtlAwareStyles().text;
+    },
+  };
+