react-native-ensys-camera-x 1.0.7

package/lib/typescript/src/localization.d.ts

@@ -0,0 +1,1051 @@
+import React, { type ReactNode } from 'react';
+import type { TextStyle, ViewStyle } from 'react-native';
+export interface CameraTranslations {
+    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;
+    photoMode: string;
+    videoMode: string;
+    recording: string;
+    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;
+    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;
+    couldNotSaveEditsSendingOriginal: string;
+    sendFailed: string;
+    sendFailedWithMessage: string;
+    addTextTitle: string;
+    addTextButton: string;
+    typeTextHint: string;
+    sizeLabel: string;
+    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;
+    /**
+     * 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;
+    emptyFile: string;
+    previewTruncated: string;
+    unsupportedPreviewKind: string;
+    fileNotPreviewableText: string;
+    couldNotOpenPdf: string;
+    cannotOpenDocumentStream: string;
+    couldNotReadFile: string;
+    webViewUnavailable: string;
+    notDecodableImage: string;
+    couldNotDecodeImage: string;
+    documentPreviewUnavailable: string;
+    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;
+    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;
+    uploadProgressTitle: string;
+    uploadProgressDescription: string;
+    uploadStatusTitle: string;
+    uploadStatusDescription: string;
+    uploadInterruptedTitle: string;
+    uploadInterruptedMessage: string;
+    uploadRetrying: string;
+    uploadCompletedTitle: string;
+    uploadCompletedMessage: string;
+    uploadFailedTitle: string;
+    uploadFailedMessage: string;
+    uploadingFileProgress: string;
+    preparingFilesProgress: string;
+    uploadingMediaTitle: string;
+    validationSelectionLimitNonNegativeInteger: string;
+    validationInitialCameraInvalid: string;
+    validationMediaTypesInvalid: string;
+    validationHoldToRecordDelayInvalid: string;
+    validationMinRecordDurationInvalid: string;
+    validationUrisMustBeArray: string;
+    validationUrisCannotBeEmpty: string;
+    validationTooManyFiles: string;
+    validationInvalidUriAtIndex: string;
+    validationAlbumNameRequired: string;
+    validationAlbumNameTooLong: string;
+    validationAlbumNameInvalidCharacters: string;
+    validationCaptionMustBeString: string;
+    validationCaptionTooLong: string;
+    validationDelayMustBeNumber: string;
+    validationDelayCannotBeNegative: string;
+    validationDelayTooLong: string;
+    validationStartTimeInvalid: string;
+    validationEndTimeInvalid: string;
+    validationStartBeforeEnd: string;
+    validationTrimDurationTooLong: string;
+    validationUploadUrlRequired: string;
+    validationUploadUrlInvalid: string;
+    validationFileTooLarge: string;
+    validationAlbumIdRequired: string;
+    validationAlbumIdTooLong: string;
+    validationDegreesMustBeNumber: string;
+    validationDegreesInvalid: string;
+    validationWidthPositive: string;
+    validationHeightPositive: string;
+    validationXNumber: string;
+    validationYNumber: string;
+    validationFilterTypeInvalid: string;
+    validationFlashModeInvalid: string;
+    validationFaceEffectInvalid: string;
+    validationThemeInvalid: string;
+    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;
+    statusProcessing: string;
+    statusSuccess: string;
+    statusUnknown: string;
+    /** Camera flash "auto" label (fixes pre-existing default without interface member). */
+    flashAuto: string;
+    unknown: string;
+    untitled: string;
+    preview: string;
+    media: string;
+    image: string;
+    video: string;
+    deleteConfirmTitle: string;
+    deleteConfirmMessage: string;
+    notSecurelyErasedTitle: string;
+    notSecurelyErasedMessage: string;
+    deleteMedia: string;
+    shareMedia: string;
+    toolFilter: string;
+    toolCrop: string;
+    toolText: string;
+    toolEmoji: string;
+    toolGrid: string;
+    emoji: string;
+    stickers: string;
+    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;
+    closeFilters: string;
+    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;
+    unknownSize: string;
+    noAppToOpenFile: string;
+    couldNotOpenFile: string;
+    pageCountSingular: string;
+    pageCountPlural: string;
+    fileCouldNotBePreviewed: string;
+    noInAppPreview: string;
+    openNamed: string;
+    open: string;
+    opening: string;
+    compressing: string;
+    errorProcessPhoto: string;
+    errorCapturePhoto: string;
+    uploadErrorCouldNotOpenStream: string;
+    uploadErrorCouldNotOpenFile: string;
+    uploadErrorServerCode: string;
+    uploadErrorNetwork: string;
+    powerPointPresentationTitle: string;
+    couldNotOpenPresentation: string;
+    couldNotReadPowerPoint: string;
+    couldNotOpenDocument: string;
+    couldNotConvertDocument: string;
+    officeBinaryPreviewNote: string;
+    unableToExtractBinaryText: string;
+    openInOfficeAppNote: string;
+    previewTruncatedRowsCols: string;
+    previewTruncatedRows: string;
+    previewTruncatedChapters: string;
+    previewTruncatedNotice: string;
+    powerPointNoSlides: string;
+    unknownDate: string;
+    aspectRatioOriginal: string;
+    aspectRatioFull: string;
+    aspectRatioOriginalShort: string;
+    gifBadge: string;
+    textFontSample: string;
+    slideNumberLabel: string;
+    docTypePowerpoint: string;
+    docTypeWord: string;
+    docTypeExcel: string;
+    docTypeOffice: string;
+    compressActiveDesc: string;
+    convertGifMessage: string;
+    convertGifCropMessage: string;
+    couldNotDecodeImageGeneric: string;
+    memoryWarningMessage: string;
+    savingEdits: string;
+    textCancel: string;
+    textFont: string;
+    textAlignment: string;
+    textBackground: string;
+    textDone: string;
+    gifSearchHint: string;
+    addingGif: string;
+    gifLoadFailed: string;
+    gifOffline: string;
+    gifTimeout: string;
+    gifServerError: string;
+    gifNoResults: string;
+    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;
+    play: string;
+    toggleVideoControls: string;
+    seekBackward: string;
+    seekForward: string;
+}
+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 declare const defaultTranslations: CameraTranslations;
+export declare const cameraLocalizationKeys: readonly (keyof CameraTranslations)[];
+/**
+ * True when a value looks like a {@link CameraLanguageProvider} rather than a
+ * language tag. Lets a single `language` option accept either one.
+ */
+export declare function isCameraLanguageProvider(value: unknown): value is CameraLanguageProvider;
+declare class LocalizationManagerImpl {
+    private translateFn?;
+    private hostTranslations?;
+    private bundles;
+    private fallbackLocale;
+    private locale;
+    private explicitIsRtl?;
+    private translations;
+    private isRtl;
+    private listeners;
+    /**
+     * 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?;
+    /** Releases {@link languageProvider}'s subscription. One at a time, always. */
+    private releaseProviderSubscription?;
+    /**
+     * 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.
+     */
+    bindLanguageProvider(provider?: CameraLanguageProvider | null, options?: {
+        resolve?: boolean;
+    }): void;
+    /** Detaches the bound provider, if any. The active language is left as-is. */
+    unbindLanguageProvider(): void;
+    /**
+     * Re-reads the bound provider and republishes if its language moved. The manual
+     * escape hatch for a host whose provider cannot notify.
+     */
+    syncLanguageFromProvider(): void;
+    /** The bound provider, for hosts that need to check whether auto-sync is on. */
+    getLanguageProvider(): CameraLanguageProvider | undefined;
+    private releaseLanguageProvider;
+    private readProviderLocale;
+    /**
+     * 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;
+    private handleProviderLanguageChange;
+    /**
+     * 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;
+    /**
+     * 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.
+     */
+    setLocalization(config?: CameraLocalizationConfig): void;
+    /**
+     * Merges a partial configuration into the current one. Use this to add bundles
+     * or change the language without re-sending everything else.
+     */
+    updateLocalization(config?: CameraLocalizationConfig): void;
+    /**
+     * 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.
+     */
+    setLanguage(locale?: string | null): void;
+    /**
+     * 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;
+    subscribe(listener: () => void): () => void;
+    getString(key: CameraTranslationKey, ...args: Array<string | number | boolean | null | undefined>): string;
+    getIsRtl(): boolean;
+    /** The active language, or `''` when the host has not set one. */
+    getLocale(): string;
+    /** The language used to fill gaps in the active one. `'en'` unless changed. */
+    getFallbackLocale(): string;
+    /** Every locale the host has registered a bundle for. */
+    getAvailableLocales(): string[];
+    getTextAlign(): 'left' | 'right';
+    getFlexDirection(): 'row' | 'row-reverse';
+    getTranslations(): CameraTranslations;
+    private notifyListeners;
+}
+export declare const LocalizationManager: 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 declare function setCameraLocalization(config?: CameraLocalizationConfig): void;
+/**
+ * Merges into the current configuration instead of replacing it. Handy for
+ * registering more bundles later, or changing one field on its own.
+ */
+export declare function updateCameraLocalization(config?: CameraLocalizationConfig): void;
+/**
+ * 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 declare function setCameraLanguageProvider(provider?: CameraLanguageProvider | null): void;
+/** Turns automatic synchronization back off. The active language is kept. */
+export declare function clearCameraLanguageProvider(): void;
+/**
+ * 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 declare function syncCameraLanguage(): void;
+/** The bound language provider, or `undefined` when auto-sync is off. */
+export declare function getCameraLanguageProvider(): CameraLanguageProvider | undefined;
+/**
+ * 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 declare function setCameraLanguage(locale?: string | null | CameraLanguageProvider): void;
+/** Registers (or replaces) translations for one or more languages. */
+export declare function registerCameraTranslations(bundles: CameraTranslationBundles): void;
+/** The plugin's active language, or `''` when the host has not set one. */
+export declare function getCameraLocale(): string;
+/** Whether plugin UI is currently laid out right-to-left. */
+export declare function getCameraIsRtl(): boolean;
+export declare function CameraLocalizationProvider({ children, translate, translations, bundles, fallbackLocale, isRtl, locale, languageProvider, version, }: CameraLocalizationProviderProps): React.FunctionComponentElement<React.ProviderProps<{
+    t: (key: CameraTranslationKey, ...args: Array<string | number | boolean | null | undefined>) => string;
+    /** The host's active language, or `''` when it has not set one. */
+    locale: string;
+    isRtl: boolean;
+    direction: string;
+    textAlign: "left" | "right";
+    flexDirection: "row" | "row-reverse";
+    rtlStyle: <T extends object>(ltr: T, rtl: T) => T;
+    writingDirectionStyle: {
+        readonly writingDirection: "rtl" | "ltr";
+        readonly textAlign: "left" | "right";
+    };
+    layoutDirectionStyle: {
+        readonly direction: "rtl" | "ltr";
+    };
+    /** Row/text styles that follow the active language's direction. */
+    styles: Readonly<{
+        row: {
+            flexDirection: "row";
+        };
+        text: {
+            writingDirection: "ltr";
+            textAlign: "left";
+        };
+    }> | Readonly<{
+        row: {
+            flexDirection: "row-reverse";
+        };
+        text: {
+            writingDirection: "rtl";
+            textAlign: "right";
+        };
+    }>;
+    translations: CameraTranslations;
+} | null>>;
+export declare function useCameraLocalization(): {
+    t: (key: CameraTranslationKey, ...args: Array<string | number | boolean | null | undefined>) => string;
+    /** The host's active language, or `''` when it has not set one. */
+    locale: string;
+    isRtl: boolean;
+    direction: string;
+    textAlign: "left" | "right";
+    flexDirection: "row" | "row-reverse";
+    rtlStyle: <T extends object>(ltr: T, rtl: T) => T;
+    writingDirectionStyle: {
+        readonly writingDirection: "rtl" | "ltr";
+        readonly textAlign: "left" | "right";
+    };
+    layoutDirectionStyle: {
+        readonly direction: "rtl" | "ltr";
+    };
+    /** Row/text styles that follow the active language's direction. */
+    styles: Readonly<{
+        row: {
+            flexDirection: "row";
+        };
+        text: {
+            writingDirection: "ltr";
+            textAlign: "left";
+        };
+    }> | Readonly<{
+        row: {
+            flexDirection: "row-reverse";
+        };
+        text: {
+            writingDirection: "rtl";
+            textAlign: "right";
+        };
+    }>;
+    translations: CameraTranslations;
+};
+export declare function useCameraLocalizationContext(): {
+    t: (key: CameraTranslationKey, ...args: Array<string | number | boolean | null | undefined>) => string;
+    /** The host's active language, or `''` when it has not set one. */
+    locale: string;
+    isRtl: boolean;
+    direction: string;
+    textAlign: "left" | "right";
+    flexDirection: "row" | "row-reverse";
+    rtlStyle: <T extends object>(ltr: T, rtl: T) => T;
+    writingDirectionStyle: {
+        readonly writingDirection: "rtl" | "ltr";
+        readonly textAlign: "left" | "right";
+    };
+    layoutDirectionStyle: {
+        readonly direction: "rtl" | "ltr";
+    };
+    /** Row/text styles that follow the active language's direction. */
+    styles: Readonly<{
+        row: {
+            flexDirection: "row";
+        };
+        text: {
+            writingDirection: "ltr";
+            textAlign: "left";
+        };
+    }> | Readonly<{
+        row: {
+            flexDirection: "row-reverse";
+        };
+        text: {
+            writingDirection: "rtl";
+            textAlign: "right";
+        };
+    }>;
+    translations: CameraTranslations;
+};
+/** Row/text styles for the active language. Prefer the hook inside components. */
+export declare function getRtlAwareStyles(): {
+    row: ViewStyle;
+    text: TextStyle;
+};
+/**
+ * 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 declare const rtlAwareStyles: {
+    readonly row: ViewStyle;
+    readonly text: TextStyle;
+};
+export {};
+//# sourceMappingURL=localization.d.ts.map