From fd7805a3ffc5cd0c8600f8a056da95d45c297445 Mon Sep 17 00:00:00 2001 From: Chihchy Date: Thu, 30 May 2024 20:49:25 +0800 Subject: [PATCH 1/3] Resolve warnings & enforce code style --- .swiftlint.yml | 1 + EhPanda/DataFlow/AppRouteReducer.swift | 9 ++++--- EhPanda/Models/Tags/TagDetail.swift | 7 ----- .../Detail/Archives/ArchivesReducer.swift | 9 ++++--- .../Detail/Comments/CommentsReducer.swift | 24 +++++++++++------ EhPanda/View/Detail/DetailReducer.swift | 26 ++++++++++++------- .../DetailSearch/DetailSearchReducer.swift | 9 ++++--- .../Detail/Previews/PreviewsReducer.swift | 2 +- .../Detail/Torrents/TorrentsReducer.swift | 4 +-- EhPanda/View/Favorites/FavoritesReducer.swift | 12 +++++---- .../Home/Frontpage/FrontpageReducer.swift | 4 +-- EhPanda/View/Home/HomeReducer.swift | 6 ++--- .../View/Home/Popular/PopularReducer.swift | 2 +- .../View/Home/Toplists/ToplistsReducer.swift | 16 ++++++++---- .../View/Home/Watched/WatchedReducer.swift | 9 ++++--- EhPanda/View/Reading/ReadingReducer.swift | 18 +++++++------ EhPanda/View/Search/SearchReducer.swift | 9 ++++--- .../Setting/EhSetting/EhSettingReducer.swift | 6 ++--- EhPanda/View/Setting/Login/LoginReducer.swift | 2 +- EhPanda/View/Setting/SettingReducer.swift | 8 +++--- 20 files changed, 107 insertions(+), 76 deletions(-) diff --git a/.swiftlint.yml b/.swiftlint.yml index 22adb80e..65bd698e 100644 --- a/.swiftlint.yml +++ b/.swiftlint.yml @@ -15,3 +15,4 @@ identifier_name: excluded: - EhPandaTests + - EhPanda/App/Generated diff --git a/EhPanda/DataFlow/AppRouteReducer.swift b/EhPanda/DataFlow/AppRouteReducer.swift index e8b41369..e657beee 100644 --- a/EhPanda/DataFlow/AppRouteReducer.swift +++ b/EhPanda/DataFlow/AppRouteReducer.swift @@ -147,8 +147,11 @@ struct AppRouteReducer: Reducer { case .fetchGallery(let url, let isGalleryImageURL): state.route = .hud return .run { send in - let response = await GalleryReverseRequest(url: url, isGalleryImageURL: isGalleryImageURL).response() - await send(Action.fetchGalleryDone(url, response)) + let response = await GalleryReverseRequest( + url: url, isGalleryImageURL: isGalleryImageURL + ) + .response() + await send(.fetchGalleryDone(url, response)) } case .fetchGalleryDone(let url, let result): @@ -164,7 +167,7 @@ struct AppRouteReducer: Reducer { case .failure: return .run { send in try await Task.sleep(for: .milliseconds(500)) - await send(Action.setHUDConfig(.error)) + await send(.setHUDConfig(.error)) } } diff --git a/EhPanda/Models/Tags/TagDetail.swift b/EhPanda/Models/Tags/TagDetail.swift index 3300a0ee..fb7a13c9 100644 --- a/EhPanda/Models/Tags/TagDetail.swift +++ b/EhPanda/Models/Tags/TagDetail.swift @@ -12,11 +12,4 @@ struct TagDetail: Equatable { let description: String let imageURLs: [URL] let links: [URL] - - init(title: String, description: String, imageURLs: [URL], links: [URL]) { - self.title = title - self.description = description - self.imageURLs = imageURLs - self.links = links - } } diff --git a/EhPanda/View/Detail/Archives/ArchivesReducer.swift b/EhPanda/View/Detail/Archives/ArchivesReducer.swift index 6c7a7510..cd843ec1 100644 --- a/EhPanda/View/Detail/Archives/ArchivesReducer.swift +++ b/EhPanda/View/Detail/Archives/ArchivesReducer.swift @@ -74,7 +74,7 @@ struct ArchivesReducer: Reducer { state.loadingState = .loading return .run { send in let response = await GalleryArchiveRequest(archiveURL: archiveURL).response() - await send(Action.fetchArchiveDone(gid, galleryURL, response)) + await send(.fetchArchiveDone(gid, galleryURL, response)) } .cancellable(id: CancelID.fetchArchive) @@ -103,7 +103,7 @@ struct ArchivesReducer: Reducer { guard let galleryURL = galleryURL.replaceHost(to: Defaults.URL.ehentai.host) else { return .none } return .run { send in let response = await GalleryArchiveFundsRequest(gid: gid, galleryURL: galleryURL).response() - await send(Action.fetchArchiveFundsDone(response)) + await send(.fetchArchiveFundsDone(response)) } .cancellable(id: CancelID.fetchArchiveFunds) @@ -122,8 +122,9 @@ struct ArchivesReducer: Reducer { let response = await SendDownloadCommandRequest( archiveURL: archiveURL, resolution: selectedArchive.resolution.parameter - ).response() - await send(Action.fetchDownloadResponseDone(response)) + ) + .response() + await send(.fetchDownloadResponseDone(response)) } .cancellable(id: CancelID.fetchDownloadResponse) diff --git a/EhPanda/View/Detail/Comments/CommentsReducer.swift b/EhPanda/View/Detail/Comments/CommentsReducer.swift index 963b6935..85a1c815 100644 --- a/EhPanda/View/Detail/Comments/CommentsReducer.swift +++ b/EhPanda/View/Detail/Comments/CommentsReducer.swift @@ -193,14 +193,18 @@ struct CommentsReducer: Reducer { commentID: commentID, content: commentContent, galleryURL: galleryURL - ).response() - await send(Action.performCommentActionDone(response)) + ) + .response() + await send(.performCommentActionDone(response)) } .cancellable(id: CancelID.postComment) } else { return .run { [commentContent = state.commentContent] send in - let response = await CommentGalleryRequest(content: commentContent, galleryURL: galleryURL).response() - await send(Action.performCommentActionDone(response)) + let response = await CommentGalleryRequest( + content: commentContent, galleryURL: galleryURL + ) + .response() + await send(.performCommentActionDone(response)) } .cancellable(id: CancelID.postComment) } @@ -217,8 +221,9 @@ struct CommentsReducer: Reducer { token: token, commentID: commentID, commentVote: vote - ).response() - await send(Action.performCommentActionDone(response)) + ) + .response() + await send(.performCommentActionDone(response)) } .cancellable(id: CancelID.voteComment) @@ -228,8 +233,11 @@ struct CommentsReducer: Reducer { case .fetchGallery(let url, let isGalleryImageURL): state.route = .hud return .run { send in - let response = await GalleryReverseRequest(url: url, isGalleryImageURL: isGalleryImageURL).response() - await send(Action.fetchGalleryDone(url, response)) + let response = await GalleryReverseRequest( + url: url, isGalleryImageURL: isGalleryImageURL + ) + .response() + await send(.fetchGalleryDone(url, response)) } .cancellable(id: CancelID.fetchGallery) diff --git a/EhPanda/View/Detail/DetailReducer.swift b/EhPanda/View/Detail/DetailReducer.swift index cf699d6c..233a22d0 100644 --- a/EhPanda/View/Detail/DetailReducer.swift +++ b/EhPanda/View/Detail/DetailReducer.swift @@ -280,7 +280,7 @@ struct DetailReducer: Reducer { state.loadingState = .loading return .run { [galleryID = state.gallery.id] send in let response = await GalleryDetailRequest(gid: galleryID, galleryURL: galleryURL).response() - await send(Action.fetchGalleryDetailDone(response)) + await send(.fetchGalleryDetailDone(response)) } .cancellable(id: CancelID.fetchGalleryDetail) @@ -325,8 +325,9 @@ struct DetailReducer: Reducer { gid: gid, token: state.gallery.token, rating: state.userRating - ).response() - await send(Action.anyGalleryOpsDone(response)) + ) + .response() + await send(.anyGalleryOpsDone(response)) }.cancellable(id: CancelID.rateGallery) case .favorGallery(let favIndex): @@ -335,23 +336,27 @@ struct DetailReducer: Reducer { gid: state.gallery.id, token: state.gallery.token, favIndex: favIndex - ).response() - await send(Action.anyGalleryOpsDone(response)) + ) + .response() + await send(.anyGalleryOpsDone(response)) } .cancellable(id: CancelID.favorGallery) case .unfavorGallery: return .run { [galleryID = state.gallery.id] send in let response = await UnfavorGalleryRequest(gid: galleryID).response() - await send(Action.anyGalleryOpsDone(response)) + await send(.anyGalleryOpsDone(response)) } .cancellable(id: CancelID.unfavorGallery) case .postComment(let galleryURL): guard !state.commentContent.isEmpty else { return .none } return .run { [commentContent = state.commentContent] send in - let response = await CommentGalleryRequest(content: commentContent, galleryURL: galleryURL).response() - await send(Action.anyGalleryOpsDone(response)) + let response = await CommentGalleryRequest( + content: commentContent, galleryURL: galleryURL + ) + .response() + await send(.anyGalleryOpsDone(response)) } .cancellable(id: CancelID.postComment) @@ -366,8 +371,9 @@ struct DetailReducer: Reducer { token: state.gallery.token, tag: tag, vote: vote - ).response() - await send(Action.anyGalleryOpsDone(response)) + ) + .response() + await send(.anyGalleryOpsDone(response)) } .cancellable(id: CancelID.voteTag) diff --git a/EhPanda/View/Detail/DetailSearch/DetailSearchReducer.swift b/EhPanda/View/Detail/DetailSearch/DetailSearchReducer.swift index 0552db23..08d4a819 100644 --- a/EhPanda/View/Detail/DetailSearch/DetailSearchReducer.swift +++ b/EhPanda/View/Detail/DetailSearch/DetailSearchReducer.swift @@ -108,7 +108,7 @@ struct DetailSearchReducer: Reducer { let filter = databaseClient.fetchFilterSynchronously(range: .search) return .run { [lastKeyword = state.lastKeyword] send in let response = await SearchGalleriesRequest(keyword: lastKeyword, filter: filter).response() - await send(Action.fetchGalleriesDone(response)) + await send(.fetchGalleriesDone(response)) } .cancellable(id: CancelID.fetchGalleries) @@ -140,8 +140,11 @@ struct DetailSearchReducer: Reducer { state.footerLoadingState = .loading let filter = databaseClient.fetchFilterSynchronously(range: .search) return .run { [lastKeyword = state.lastKeyword] send in - let response = await MoreSearchGalleriesRequest(keyword: lastKeyword, filter: filter, lastID: lastID).response() - await send(Action.fetchMoreGalleriesDone(response)) + let response = await MoreSearchGalleriesRequest( + keyword: lastKeyword, filter: filter, lastID: lastID + ) + .response() + await send(.fetchMoreGalleriesDone(response)) } .cancellable(id: CancelID.fetchMoreGalleries) diff --git a/EhPanda/View/Detail/Previews/PreviewsReducer.swift b/EhPanda/View/Detail/Previews/PreviewsReducer.swift index ca3bcb01..a25881c6 100644 --- a/EhPanda/View/Detail/Previews/PreviewsReducer.swift +++ b/EhPanda/View/Detail/Previews/PreviewsReducer.swift @@ -113,7 +113,7 @@ struct PreviewsReducer: Reducer { let pageNum = state.previewConfig.pageNumber(index: index) return .run { send in let response = await GalleryPreviewURLsRequest(galleryURL: galleryURL, pageNum: pageNum).response() - await send(Action.fetchPreviewURLsDone(response)) + await send(.fetchPreviewURLsDone(response)) } .cancellable(id: CancelID.fetchPreviewURLs) diff --git a/EhPanda/View/Detail/Torrents/TorrentsReducer.swift b/EhPanda/View/Detail/Torrents/TorrentsReducer.swift index 36f47431..cf10db19 100644 --- a/EhPanda/View/Detail/Torrents/TorrentsReducer.swift +++ b/EhPanda/View/Detail/Torrents/TorrentsReducer.swift @@ -76,7 +76,7 @@ struct TorrentsReducer: Reducer { case .fetchTorrent(let hash, let torrentURL): return .run { send in let response = await DataRequest(url: torrentURL).response() - await send(Action.fetchTorrentDone(hash, response)) + await send(.fetchTorrentDone(hash, response)) } .cancellable(id: CancelID.fetchTorrent) @@ -94,7 +94,7 @@ struct TorrentsReducer: Reducer { state.loadingState = .loading return .run { send in let response = await GalleryTorrentsRequest(gid: gid, token: token).response() - await send(Action.fetchGalleryTorrentsDone(response)) + await send(.fetchGalleryTorrentsDone(response)) } .cancellable(id: CancelID.fetchGalleryTorrents) diff --git a/EhPanda/View/Favorites/FavoritesReducer.swift b/EhPanda/View/Favorites/FavoritesReducer.swift index e2829885..b0b5676b 100644 --- a/EhPanda/View/Favorites/FavoritesReducer.swift +++ b/EhPanda/View/Favorites/FavoritesReducer.swift @@ -93,7 +93,7 @@ struct FavoritesReducer: Reducer { case .setFavoritesIndex(let index): state.index = index guard state.galleries?.isEmpty != false else { return .none } - return .send(Action.fetchGalleries()) + return .send(.fetchGalleries()) case .clearSubStates: state.detailState = .init() @@ -116,8 +116,9 @@ struct FavoritesReducer: Reducer { return .run { [state] send in let response = await FavoritesGalleriesRequest( favIndex: state.index, keyword: state.keyword, sortOrder: sortOrder - ).response() - await send(Action.fetchGalleriesDone(state.index, response)) + ) + .response() + await send(.fetchGalleriesDone(state.index, response)) } case .fetchGalleriesDone(let targetFavIndex, let result): @@ -154,8 +155,9 @@ struct FavoritesReducer: Reducer { lastID: lastID, lastTimestamp: lastItemTimestamp, keyword: state.keyword - ).response() - await send(Action.fetchMoreGalleriesDone(state.index, response)) + ) + .response() + await send(.fetchMoreGalleriesDone(state.index, response)) } case .fetchMoreGalleriesDone(let targetFavIndex, let result): diff --git a/EhPanda/View/Home/Frontpage/FrontpageReducer.swift b/EhPanda/View/Home/Frontpage/FrontpageReducer.swift index c8c7c983..65e1367a 100644 --- a/EhPanda/View/Home/Frontpage/FrontpageReducer.swift +++ b/EhPanda/View/Home/Frontpage/FrontpageReducer.swift @@ -94,7 +94,7 @@ struct FrontpageReducer: Reducer { let filter = databaseClient.fetchFilterSynchronously(range: .global) return .run { send in let response = await FrontpageGalleriesRequest(filter: filter).response() - await send(Action.fetchGalleriesDone(response)) + await send(.fetchGalleriesDone(response)) } .cancellable(id: CancelID.fetchGalleries) @@ -127,7 +127,7 @@ struct FrontpageReducer: Reducer { let filter = databaseClient.fetchFilterSynchronously(range: .global) return .run { send in let response = await MoreFrontpageGalleriesRequest(filter: filter, lastID: lastID).response() - await send(Action.fetchMoreGalleriesDone(response)) + await send(.fetchMoreGalleriesDone(response)) } .cancellable(id: CancelID.fetchMoreGalleries) diff --git a/EhPanda/View/Home/HomeReducer.swift b/EhPanda/View/Home/HomeReducer.swift index 3b6ccc68..318af824 100644 --- a/EhPanda/View/Home/HomeReducer.swift +++ b/EhPanda/View/Home/HomeReducer.swift @@ -157,7 +157,7 @@ struct HomeReducer: Reducer { let filter = databaseClient.fetchFilterSynchronously(range: .global) return .run { send in let response = await PopularGalleriesRequest(filter: filter).response() - await send(Action.fetchPopularGalleriesDone(response)) + await send(.fetchPopularGalleriesDone(response)) } case .fetchPopularGalleriesDone(let result): @@ -183,7 +183,7 @@ struct HomeReducer: Reducer { let filter = databaseClient.fetchFilterSynchronously(range: .global) return .run { send in let response = await FrontpageGalleriesRequest(filter: filter).response() - await send(Action.fetchFrontpageGalleriesDone(response)) + await send(.fetchFrontpageGalleriesDone(response)) } case .fetchFrontpageGalleriesDone(let result): @@ -208,7 +208,7 @@ struct HomeReducer: Reducer { state.toplistsLoadingState[index] = .loading return .run { send in let response = await ToplistsGalleriesRequest(catIndex: index, pageNum: pageNum).response() - await send(Action.fetchToplistsGalleriesDone(index, response)) + await send(.fetchToplistsGalleriesDone(index, response)) } case .fetchToplistsGalleriesDone(let index, let result): diff --git a/EhPanda/View/Home/Popular/PopularReducer.swift b/EhPanda/View/Home/Popular/PopularReducer.swift index b5beedd5..405d9690 100644 --- a/EhPanda/View/Home/Popular/PopularReducer.swift +++ b/EhPanda/View/Home/Popular/PopularReducer.swift @@ -81,7 +81,7 @@ struct PopularReducer: Reducer { let filter = databaseClient.fetchFilterSynchronously(range: .global) return .run { send in let response = await PopularGalleriesRequest(filter: filter).response() - await send(Action.fetchGalleriesDone(response)) + await send(.fetchGalleriesDone(response)) } .cancellable(id: CancelID.fetchGalleries) diff --git a/EhPanda/View/Home/Toplists/ToplistsReducer.swift b/EhPanda/View/Home/Toplists/ToplistsReducer.swift index 7cca9ac7..aa22b506 100644 --- a/EhPanda/View/Home/Toplists/ToplistsReducer.swift +++ b/EhPanda/View/Home/Toplists/ToplistsReducer.swift @@ -109,7 +109,7 @@ struct ToplistsReducer: Reducer { case .setToplistsType(let type): state.type = type guard state.galleries?.isEmpty != false else { return .none } - return .send(Action.fetchGalleries()) + return .send(.fetchGalleries()) case .clearSubStates: state.detailState = .init() @@ -147,8 +147,11 @@ struct ToplistsReducer: Reducer { state.rawPageNumber[state.type]?.resetPages() } return .run { [type = state.type] send in - let response = await ToplistsGalleriesRequest(catIndex: type.categoryIndex, pageNum: pageNum).response() - await send(Action.fetchGalleriesDone(type, response)) + let response = await ToplistsGalleriesRequest( + catIndex: type.categoryIndex, pageNum: pageNum + ) + .response() + await send(.fetchGalleriesDone(type, response)) } .cancellable(id: CancelID.fetchGalleries) @@ -179,8 +182,11 @@ struct ToplistsReducer: Reducer { state.rawFooterLoadingState[state.type] = .loading let pageNum = pageNumber.current + 1 return .run { [type = state.type] send in - let response = await MoreToplistsGalleriesRequest(catIndex: type.categoryIndex, pageNum: pageNum).response() - await send(Action.fetchMoreGalleriesDone(type, response)) + let response = await MoreToplistsGalleriesRequest( + catIndex: type.categoryIndex, pageNum: pageNum + ) + .response() + await send(.fetchMoreGalleriesDone(type, response)) } .cancellable(id: CancelID.fetchMoreGalleries) diff --git a/EhPanda/View/Home/Watched/WatchedReducer.swift b/EhPanda/View/Home/Watched/WatchedReducer.swift index 35407d48..d14f6939 100644 --- a/EhPanda/View/Home/Watched/WatchedReducer.swift +++ b/EhPanda/View/Home/Watched/WatchedReducer.swift @@ -104,7 +104,7 @@ struct WatchedReducer: Reducer { let filter = databaseClient.fetchFilterSynchronously(range: .watched) return .run { [keyword = state.keyword] send in let response = await WatchedGalleriesRequest(filter: filter, keyword: keyword).response() - await send(Action.fetchGalleriesDone(response)) + await send(.fetchGalleriesDone(response)) } .cancellable(id: CancelID.fetchGalleries) @@ -136,8 +136,11 @@ struct WatchedReducer: Reducer { state.footerLoadingState = .loading let filter = databaseClient.fetchFilterSynchronously(range: .watched) return .run { [keyword = state.keyword] send in - let response = await MoreWatchedGalleriesRequest(filter: filter, lastID: lastID, keyword: keyword).response() - await send(Action.fetchMoreGalleriesDone(response)) + let response = await MoreWatchedGalleriesRequest( + filter: filter, lastID: lastID, keyword: keyword + ) + .response() + await send(.fetchMoreGalleriesDone(response)) } .cancellable(id: CancelID.fetchMoreGalleries) diff --git a/EhPanda/View/Reading/ReadingReducer.swift b/EhPanda/View/Reading/ReadingReducer.swift index 7dbe483f..98de95f4 100644 --- a/EhPanda/View/Reading/ReadingReducer.swift +++ b/EhPanda/View/Reading/ReadingReducer.swift @@ -385,7 +385,7 @@ struct ReadingReducer: Reducer { let pageNum = state.previewConfig.pageNumber(index: index) return .run { send in let response = await GalleryPreviewURLsRequest(galleryURL: galleryURL, pageNum: pageNum).response() - await send(Action.fetchPreviewURLsDone(index, response)) + await send(.fetchPreviewURLsDone(index, response)) } .cancellable(id: CancelID.fetchPreviewURLs) @@ -468,7 +468,7 @@ struct ReadingReducer: Reducer { let pageNum = state.previewConfig.pageNumber(index: index) return .run { send in let response = await ThumbnailURLsRequest(galleryURL: galleryURL, pageNum: pageNum).response() - await send(Action.fetchThumbnailURLsDone(index, response)) + await send(.fetchThumbnailURLsDone(index, response)) } .cancellable(id: CancelID.fetchThumbnailURLs) @@ -501,7 +501,7 @@ struct ReadingReducer: Reducer { case .fetchNormalImageURLs(let index, let thumbnailURLs): return .run { send in let response = await GalleryNormalImageURLsRequest(thumbnailURLs: thumbnailURLs).response() - await send(Action.fetchNormalImageURLsDone(index, response)) + await send(.fetchNormalImageURLsDone(index, response)) } .cancellable(id: CancelID.fetchNormalImageURLs) @@ -541,8 +541,9 @@ struct ReadingReducer: Reducer { galleryURL: galleryURL, thumbnailURL: thumbnailURL, storedImageURL: imageURL - ).response() - await send(Action.refetchNormalImageURLsDone(index, response)) + ) + .response() + await send(.refetchNormalImageURLsDone(index, response)) } .cancellable(id: CancelID.refetchNormalImageURLs) @@ -571,7 +572,7 @@ struct ReadingReducer: Reducer { case .fetchMPVKeys(let index, let mpvURL): return .run { send in let response = await MPVKeysRequest(mpvURL: mpvURL).response() - await send(Action.fetchMPVKeysDone(index, response)) + await send(.fetchMPVKeysDone(index, response)) } .cancellable(id: CancelID.fetchMPVKeys) @@ -617,8 +618,9 @@ struct ReadingReducer: Reducer { mpvKey: mpvKey, mpvImageKey: mpvImageKey, skipServerIdentifier: skipServerIdentifier - ).response() - await send(Action.fetchMPVImageURLDone(index, response)) + ) + .response() + await send(.fetchMPVImageURLDone(index, response)) } .cancellable(id: CancelID.fetchMPVImageURL) diff --git a/EhPanda/View/Search/SearchReducer.swift b/EhPanda/View/Search/SearchReducer.swift index b35d981c..9c0ff6fb 100644 --- a/EhPanda/View/Search/SearchReducer.swift +++ b/EhPanda/View/Search/SearchReducer.swift @@ -108,7 +108,7 @@ struct SearchReducer: Reducer { let filter = databaseClient.fetchFilterSynchronously(range: .search) return .run { [lastKeyword = state.lastKeyword] send in let response = await SearchGalleriesRequest(keyword: lastKeyword, filter: filter).response() - await send(Action.fetchGalleriesDone(response)) + await send(.fetchGalleriesDone(response)) } .cancellable(id: CancelID.fetchGalleries) @@ -140,8 +140,11 @@ struct SearchReducer: Reducer { state.footerLoadingState = .loading let filter = databaseClient.fetchFilterSynchronously(range: .search) return .run { [lastKeyword = state.lastKeyword] send in - let response = await MoreSearchGalleriesRequest(keyword: lastKeyword, filter: filter, lastID: lastID).response() - await send(Action.fetchMoreGalleriesDone(response)) + let response = await MoreSearchGalleriesRequest( + keyword: lastKeyword, filter: filter, lastID: lastID + ) + .response() + await send(.fetchMoreGalleriesDone(response)) } .cancellable(id: CancelID.fetchMoreGalleries) diff --git a/EhPanda/View/Setting/EhSetting/EhSettingReducer.swift b/EhPanda/View/Setting/EhSetting/EhSettingReducer.swift index 08db041a..b2af2f6b 100644 --- a/EhPanda/View/Setting/EhSetting/EhSettingReducer.swift +++ b/EhPanda/View/Setting/EhSetting/EhSettingReducer.swift @@ -86,7 +86,7 @@ struct EhSettingReducer: Reducer { state.loadingState = .loading return .run { send in let response = await EhSettingRequest().response() - await send(Action.fetchEhSettingDone(response)) + await send(.fetchEhSettingDone(response)) } .cancellable(id: CancelID.fetchEhSetting) @@ -109,7 +109,7 @@ struct EhSettingReducer: Reducer { state.submittingState = .loading return .run { send in let response = await SubmitEhSettingChangesRequest(ehSetting: ehSetting).response() - await send(Action.submitChangesDone(response)) + await send(.submitChangesDone(response)) } .cancellable(id: CancelID.submitChanges) @@ -129,7 +129,7 @@ struct EhSettingReducer: Reducer { state.submittingState = .loading return .run { send in let response = await EhProfileRequest(action: action, name: name, set: set).response() - await send(Action.performActionDone(response)) + await send(.performActionDone(response)) } .cancellable(id: CancelID.performAction) diff --git a/EhPanda/View/Setting/Login/LoginReducer.swift b/EhPanda/View/Setting/Login/LoginReducer.swift index e94420f7..b66dd23b 100644 --- a/EhPanda/View/Setting/Login/LoginReducer.swift +++ b/EhPanda/View/Setting/Login/LoginReducer.swift @@ -75,7 +75,7 @@ struct LoginReducer: Reducer { }, .run { [state] send in let response = await LoginRequest(username: state.username, password: state.password).response() - await send(Action.loginDone(response)) + await send(.loginDone(response)) } .cancellable(id: CancelID.login) ) diff --git a/EhPanda/View/Setting/SettingReducer.swift b/EhPanda/View/Setting/SettingReducer.swift index bb8dfb2f..969f0968 100644 --- a/EhPanda/View/Setting/SettingReducer.swift +++ b/EhPanda/View/Setting/SettingReducer.swift @@ -314,7 +314,7 @@ struct SettingReducer: Reducer { guard cookieClient.didLogin else { return .none } return .run { send in let response = await IgneousRequest().response() - await send(Action.fetchIgneousDone(response)) + await send(.fetchIgneousDone(response)) } case .fetchIgneousDone(let result): @@ -334,7 +334,7 @@ struct SettingReducer: Reducer { if !uid.isEmpty { return .run { send in let response = await UserInfoRequest(uid: uid).response() - await send(Action.fetchUserInfoDone(response)) + await send(.fetchUserInfoDone(response)) } } return .none @@ -433,7 +433,7 @@ struct SettingReducer: Reducer { guard cookieClient.didLogin else { return .none } return .run { send in let response = await VerifyEhProfileRequest().response() - await send(Action.fetchEhProfileIndexDone(response)) + await send(.fetchEhProfileIndexDone(response)) } case .fetchEhProfileIndexDone(let result): @@ -468,7 +468,7 @@ struct SettingReducer: Reducer { guard cookieClient.didLogin else { return .none } return .run { send in let response = await FavoriteCategoriesRequest().response() - await send(Action.fetchFavoriteCategoriesDone(response)) + await send(.fetchFavoriteCategoriesDone(response)) } case .fetchFavoriteCategoriesDone(let result): From 557a1b792ec5ce1c60141de94b00d80ec848567e Mon Sep 17 00:00:00 2001 From: Chihchy Date: Thu, 30 May 2024 21:20:02 +0800 Subject: [PATCH 2/3] Update CI --- .github/workflows/dependencies.yml | 10 ++++------ .github/workflows/deploy.yml | 24 +++++++++++++++++------- .github/workflows/test.yml | 12 ++++++------ 3 files changed, 27 insertions(+), 19 deletions(-) diff --git a/.github/workflows/dependencies.yml b/.github/workflows/dependencies.yml index 598c4232..0b38e16a 100644 --- a/.github/workflows/dependencies.yml +++ b/.github/workflows/dependencies.yml @@ -2,16 +2,13 @@ name: Xcode Dependencies on: schedule: - cron: '0 0 * * 1' - push: - branches: - - main + workflow_dispatch: permissions: contents: write pull-requests: write jobs: dependencies: - runs-on: macos-13 - if: ${{ contains(github.event.head_commit.message, '[update dependencies]') || github.event_name == 'schedule' }} + runs-on: macos-14 steps: - uses: actions/checkout@v4 with: @@ -22,9 +19,10 @@ jobs: with: forceResolution: true failWhenOutdated: false + xcodePath: '/Applications/Xcode_15.4.app' - name: Create Pull Request if: steps.resolution.outputs.dependenciesChanged == 'true' - uses: peter-evans/create-pull-request@v5 + uses: peter-evans/create-pull-request@v6 with: branch: 'update-dependencies' delete-branch: true diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml index 1d5f8b25..7ccae4ff 100644 --- a/.github/workflows/deploy.yml +++ b/.github/workflows/deploy.yml @@ -5,7 +5,7 @@ on: - main types: [closed] env: - DEVELOPER_DIR: /Applications/Xcode_15.0.1.app + DEVELOPER_DIR: /Applications/Xcode_15.4.app APP_VERSION: '2.7.4' SCHEME_NAME: 'EhPanda' ALTSTORE_JSON_PATH: './AltStore.json' @@ -19,7 +19,7 @@ env: jobs: Deploy: - runs-on: macos-13 + runs-on: macos-14 if: github.event.pull_request.merged == true && github.event.pull_request.user.login == 'chihchy' steps: - name: Checkout @@ -28,12 +28,13 @@ jobs: run: | git config user.name "github-actions[bot]" git config user.email "41898282+github-actions[bot]@users.noreply.github.com" - - name: Install dependencies - run: brew install swiftgen - name: Show Xcode version run: xcodebuild -version - name: Run tests - run: xcodebuild clean test -scheme ${{ env.SCHEME_NAME }} -sdk iphonesimulator + run: xcodebuild clean test + -skipMacroValidation + -sdk iphonesimulator + -scheme ${{ env.SCHEME_NAME }} -destination 'platform=iOS Simulator,name=iPhone 15 Pro' - name: Bump version id: bump-version @@ -41,8 +42,17 @@ jobs: with: version: ${{ env.APP_VERSION }} - name: Xcode archive - run: xcodebuild archive -destination 'generic/platform=iOS' - -scheme ${{ env.SCHEME_NAME }} -archivePath ${{ env.ARCHIVE_PATH }} CODE_SIGNING_REQUIRED=NO CODE_SIGNING_ALLOWED=NO CODE_SIGN_IDENTITY= CODE_SIGN_ENTITLEMENTS= GCC_OPTIMIZATION_LEVEL=s SWIFT_OPTIMIZATION_LEVEL=-O + run: xcodebuild archive + -skipMacroValidation + -scheme ${{ env.SCHEME_NAME }} + -destination 'generic/platform=iOS' + -archivePath ${{ env.ARCHIVE_PATH }} + CODE_SIGN_IDENTITY= + CODE_SIGN_ENTITLEMENTS= + CODE_SIGNING_ALLOWED=NO + CODE_SIGNING_REQUIRED=NO + GCC_OPTIMIZATION_LEVEL=s + SWIFT_OPTIMIZATION_LEVEL=-O - name: Export .ipa file run: | mkdir -p ${{ env.PAYLOAD_PATH }} diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 080eaa10..56f0cb02 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -1,20 +1,20 @@ name: Test -on: [push] +on: [push, workflow_dispatch] env: SCHEME_NAME: 'EhPanda' - DEVELOPER_DIR: /Applications/Xcode_15.0.1.app + DEVELOPER_DIR: /Applications/Xcode_15.4.app jobs: Test: - runs-on: macos-13 + runs-on: macos-14 if: ${{ !contains(github.event.head_commit.message, '[skip test]') }} steps: - name: Checkout uses: actions/checkout@v4 - - name: Install dependencies - run: brew install swiftgen - name: Show Xcode version run: xcodebuild -version - name: Run tests run: xcodebuild clean test - -scheme ${{ env.SCHEME_NAME }} -sdk iphonesimulator + -skipMacroValidation + -sdk iphonesimulator + -scheme ${{ env.SCHEME_NAME }} -destination 'platform=iOS Simulator,name=iPhone 15 Pro' From 033d8bcbc6163deed7ccb45f39ab9d7c0e5a9d72 Mon Sep 17 00:00:00 2001 From: Chihchy Date: Thu, 30 May 2024 21:33:15 +0800 Subject: [PATCH 3/3] Stop ignoring generated files in git --- .gitignore | 1 - EhPanda/App/Generated/Strings.swift | 2225 +++++++++++++++++++++++++++ 2 files changed, 2225 insertions(+), 1 deletion(-) create mode 100644 EhPanda/App/Generated/Strings.swift diff --git a/.gitignore b/.gitignore index 2f7dea2b..ee8327b3 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,3 @@ .DS_Store -EhPanda/App/Generated EhPanda.xcodeproj/xcuserdata EhPanda.xcodeproj/project.xcworkspace/xcuserdata \ No newline at end of file diff --git a/EhPanda/App/Generated/Strings.swift b/EhPanda/App/Generated/Strings.swift new file mode 100644 index 00000000..ea82faca --- /dev/null +++ b/EhPanda/App/Generated/Strings.swift @@ -0,0 +1,2225 @@ +// swiftlint:disable all +// Generated using SwiftGen — https://github.com/SwiftGen/SwiftGen + +import Foundation + +// swiftlint:disable superfluous_disable_command file_length implicit_return prefer_self_in_static_references + +// MARK: - Strings + +// swiftlint:disable explicit_type_interface function_parameter_count identifier_name line_length +// swiftlint:disable nesting type_body_length type_name vertical_whitespace_opening_braces +internal enum L10n { + internal enum Constant { + internal enum App { + /// Copyright © 2023 EhPanda Team + internal static let copyright = L10n.tr("Constant", "app.copyright", fallback: "Copyright © 2023 EhPanda Team") + internal enum Acknowledgement { + internal enum Link { + /// https://github.com/rebeloper/AlertKit + internal static let alertKit = L10n.tr("Constant", "app.acknowledgement.link.alertKit", fallback: "https://github.com/rebeloper/AlertKit") + /// https://github.com/Co2333/Colorful + internal static let colorful = L10n.tr("Constant", "app.acknowledgement.link.colorful", fallback: "https://github.com/Co2333/Colorful") + /// https://github.com/EhTagTranslation/Database + internal static let ehTagTranslationDatabase = L10n.tr("Constant", "app.acknowledgement.link.ehTagTranslationDatabase", fallback: "https://github.com/EhTagTranslation/Database") + /// https://github.com/markrenaud/FilePicker + internal static let filePicker = L10n.tr("Constant", "app.acknowledgement.link.filePicker", fallback: "https://github.com/markrenaud/FilePicker") + /// https://github.com/tid-kijyun/Kanna + internal static let kanna = L10n.tr("Constant", "app.acknowledgement.link.kanna", fallback: "https://github.com/tid-kijyun/Kanna") + /// https://github.com/onevcat/Kingfisher + internal static let kingfisher = L10n.tr("Constant", "app.acknowledgement.link.kingfisher", fallback: "https://github.com/onevcat/Kingfisher") + /// https://github.com/SFSafeSymbols/SFSafeSymbols + internal static let sfSafeSymbols = L10n.tr("Constant", "app.acknowledgement.link.sfSafeSymbols", fallback: "https://github.com/SFSafeSymbols/SFSafeSymbols") + /// https://github.com/gonzalezreal/SwiftCommonMark + internal static let swiftCommonMark = L10n.tr("Constant", "app.acknowledgement.link.swiftCommonMark", fallback: "https://github.com/gonzalezreal/SwiftCommonMark") + /// https://github.com/SwiftGen/SwiftGen + internal static let swiftGen = L10n.tr("Constant", "app.acknowledgement.link.swiftGen", fallback: "https://github.com/SwiftGen/SwiftGen") + /// https://github.com/pointfreeco/swiftui-navigation + internal static let swiftUINavigation = L10n.tr("Constant", "app.acknowledgement.link.swiftUINavigation", fallback: "https://github.com/pointfreeco/swiftui-navigation") + /// https://github.com/fermoya/SwiftUIPager + internal static let swiftUIPager = L10n.tr("Constant", "app.acknowledgement.link.swiftUIPager", fallback: "https://github.com/fermoya/SwiftUIPager") + /// https://github.com/SwiftyBeaver/SwiftyBeaver + internal static let swiftyBeaver = L10n.tr("Constant", "app.acknowledgement.link.swiftyBeaver", fallback: "https://github.com/SwiftyBeaver/SwiftyBeaver") + /// https://github.com/ddddxxx/SwiftyOpenCC + internal static let swiftyOpenCC = L10n.tr("Constant", "app.acknowledgement.link.swiftyOpenCC", fallback: "https://github.com/ddddxxx/SwiftyOpenCC") + /// https://github.com/pointfreeco/swift-composable-architecture + internal static let tca = L10n.tr("Constant", "app.acknowledgement.link.tca", fallback: "https://github.com/pointfreeco/swift-composable-architecture") + /// https://github.com/honkmaster/TTProgressHUD + internal static let ttProgressHUD = L10n.tr("Constant", "app.acknowledgement.link.ttProgressHUD", fallback: "https://github.com/honkmaster/TTProgressHUD") + /// https://github.com/jathu/UIImageColors + internal static let uiImageColors = L10n.tr("Constant", "app.acknowledgement.link.uiImageColors", fallback: "https://github.com/jathu/UIImageColors") + /// https://github.com/paololeonardi/WaterfallGrid + internal static let waterfallGrid = L10n.tr("Constant", "app.acknowledgement.link.waterfallGrid", fallback: "https://github.com/paololeonardi/WaterfallGrid") + } + internal enum Text { + /// AlertKit + internal static let alertKit = L10n.tr("Constant", "app.acknowledgement.text.alertKit", fallback: "AlertKit") + /// Colorful + internal static let colorful = L10n.tr("Constant", "app.acknowledgement.text.colorful", fallback: "Colorful") + /// EhTagTranslation/Database + internal static let ehTagTranslationDatabase = L10n.tr("Constant", "app.acknowledgement.text.ehTagTranslationDatabase", fallback: "EhTagTranslation/Database") + /// FilePicker + internal static let filePicker = L10n.tr("Constant", "app.acknowledgement.text.filePicker", fallback: "FilePicker") + /// Kanna + internal static let kanna = L10n.tr("Constant", "app.acknowledgement.text.kanna", fallback: "Kanna") + /// Kingfisher + internal static let kingfisher = L10n.tr("Constant", "app.acknowledgement.text.kingfisher", fallback: "Kingfisher") + /// SFSafeSymbols + internal static let sfSafeSymbols = L10n.tr("Constant", "app.acknowledgement.text.sfSafeSymbols", fallback: "SFSafeSymbols") + /// SwiftCommonMark + internal static let swiftCommonMark = L10n.tr("Constant", "app.acknowledgement.text.swiftCommonMark", fallback: "SwiftCommonMark") + /// SwiftGen + internal static let swiftGen = L10n.tr("Constant", "app.acknowledgement.text.swiftGen", fallback: "SwiftGen") + /// SwiftUI Navigation + internal static let swiftUINavigation = L10n.tr("Constant", "app.acknowledgement.text.swiftUINavigation", fallback: "SwiftUI Navigation") + /// SwiftUIPager + internal static let swiftUIPager = L10n.tr("Constant", "app.acknowledgement.text.swiftUIPager", fallback: "SwiftUIPager") + /// SwiftyBeaver + internal static let swiftyBeaver = L10n.tr("Constant", "app.acknowledgement.text.swiftyBeaver", fallback: "SwiftyBeaver") + /// SwiftyOpenCC + internal static let swiftyOpenCC = L10n.tr("Constant", "app.acknowledgement.text.swiftyOpenCC", fallback: "SwiftyOpenCC") + /// The Composable Architecture + internal static let tca = L10n.tr("Constant", "app.acknowledgement.text.tca", fallback: "The Composable Architecture") + /// TTProgressHUD + internal static let ttProgressHUD = L10n.tr("Constant", "app.acknowledgement.text.ttProgressHUD", fallback: "TTProgressHUD") + /// UIImageColors + internal static let uiImageColors = L10n.tr("Constant", "app.acknowledgement.text.uiImageColors", fallback: "UIImageColors") + /// WaterfallGrid + internal static let waterfallGrid = L10n.tr("Constant", "app.acknowledgement.text.waterfallGrid", fallback: "WaterfallGrid") + } + } + internal enum CodeLevelContributor { + internal enum Link { + /// https://github.com/chihchy + internal static let chihchy = L10n.tr("Constant", "app.code_level_contributor.link.chihchy", fallback: "https://github.com/chihchy") + /// https://github.com/Jimmy-Prime + internal static let jimmyPrime = L10n.tr("Constant", "app.code_level_contributor.link.Jimmy-Prime", fallback: "https://github.com/Jimmy-Prime") + /// https://github.com/remlostime + internal static let remlostime = L10n.tr("Constant", "app.code_level_contributor.link.remlostime", fallback: "https://github.com/remlostime") + /// https://github.com/tatsuz0u + internal static let tatsuz0u = L10n.tr("Constant", "app.code_level_contributor.link.tatsuz0u", fallback: "https://github.com/tatsuz0u") + /// https://github.com/xioxin + internal static let xioxin = L10n.tr("Constant", "app.code_level_contributor.link.xioxin", fallback: "https://github.com/xioxin") + } + internal enum Text { + /// Chihchy + internal static let chihchy = L10n.tr("Constant", "app.code_level_contributor.text.chihchy", fallback: "Chihchy") + /// Jimmy Prime + internal static let jimmyPrime = L10n.tr("Constant", "app.code_level_contributor.text.Jimmy-Prime", fallback: "Jimmy Prime") + /// Kai Chen + internal static let remlostime = L10n.tr("Constant", "app.code_level_contributor.text.remlostime", fallback: "Kai Chen") + /// Tatsuzo Araki + internal static let tatsuz0u = L10n.tr("Constant", "app.code_level_contributor.text.tatsuz0u", fallback: "Tatsuzo Araki") + /// xioxin + internal static let xioxin = L10n.tr("Constant", "app.code_level_contributor.text.xioxin", fallback: "xioxin") + } + } + internal enum Contact { + internal enum Link { + /// altstore://source?url=https://github.com/EhPanda-Team/EhPanda/raw/main/AltStore.json + internal static let altStore = L10n.tr("Constant", "app.contact.link.altStore", fallback: "altstore://source?url=https://github.com/EhPanda-Team/EhPanda/raw/main/AltStore.json") + /// https://discord.gg/BSBE9FCBTq + internal static let discord = L10n.tr("Constant", "app.contact.link.discord", fallback: "https://discord.gg/BSBE9FCBTq") + /// https://github.com/EhPanda-Team/EhPanda + internal static let gitHub = L10n.tr("Constant", "app.contact.link.gitHub", fallback: "https://github.com/EhPanda-Team/EhPanda") + /// https://t.me/ehpanda + internal static let telegram = L10n.tr("Constant", "app.contact.link.telegram", fallback: "https://t.me/ehpanda") + /// https://ehpanda.app + internal static let website = L10n.tr("Constant", "app.contact.link.website", fallback: "https://ehpanda.app") + } + internal enum Text { + /// Discord + internal static let discord = L10n.tr("Constant", "app.contact.text.discord", fallback: "Discord") + /// GitHub + internal static let gitHub = L10n.tr("Constant", "app.contact.text.gitHub", fallback: "GitHub") + /// Telegram + internal static let telegram = L10n.tr("Constant", "app.contact.text.telegram", fallback: "Telegram") + } + } + internal enum SpecialThanks { + internal enum Link { + /// https://github.com/caxerx + internal static let caxerx = L10n.tr("Constant", "app.special_thanks.link.caxerx", fallback: "https://github.com/caxerx") + /// https://github.com/honjow + internal static let honjow = L10n.tr("Constant", "app.special_thanks.link.honjow", fallback: "https://github.com/honjow") + /// + internal static let luminescentYq = L10n.tr("Constant", "app.special_thanks.link.luminescent_yq", fallback: "") + /// https://github.com/taylorlannister + internal static let taylorlannister = L10n.tr("Constant", "app.special_thanks.link.taylorlannister", fallback: "https://github.com/taylorlannister") + } + internal enum Text { + /// caxerx + internal static let caxerx = L10n.tr("Constant", "app.special_thanks.text.caxerx", fallback: "caxerx") + /// honjow + internal static let honjow = L10n.tr("Constant", "app.special_thanks.text.honjow", fallback: "honjow") + /// Luminescent_yq + internal static let luminescentYq = L10n.tr("Constant", "app.special_thanks.text.luminescent_yq", fallback: "Luminescent_yq") + /// taylorlannister + internal static let taylorlannister = L10n.tr("Constant", "app.special_thanks.text.taylorlannister", fallback: "taylorlannister") + } + } + internal enum TranslationContributor { + internal enum Link { + /// https://github.com/caxerx + internal static let caxerx = L10n.tr("Constant", "app.translation_contributor.link.caxerx", fallback: "https://github.com/caxerx") + /// https://github.com/Nebulosa-Cat + internal static let nebulosaCat = L10n.tr("Constant", "app.translation_contributor.link.nebulosa-cat", fallback: "https://github.com/Nebulosa-Cat") + /// https://github.com/nyaanim + internal static let nyaanim = L10n.tr("Constant", "app.translation_contributor.link.nyaanim", fallback: "https://github.com/nyaanim") + /// https://github.com/PaulHaeussler + internal static let paulHaeussler = L10n.tr("Constant", "app.translation_contributor.link.paulHaeussler", fallback: "https://github.com/PaulHaeussler") + /// https://github.com/tatsuz0u + internal static let tatsuz0u = L10n.tr("Constant", "app.translation_contributor.link.tatsuz0u", fallback: "https://github.com/tatsuz0u") + } + internal enum Text { + /// caxerx + internal static let caxerx = L10n.tr("Constant", "app.translation_contributor.text.caxerx", fallback: "caxerx") + /// 雲豹 ΦωΦ + internal static let nebulosaCat = L10n.tr("Constant", "app.translation_contributor.text.nebulosa-cat", fallback: "雲豹 ΦωΦ") + /// nyaanim + internal static let nyaanim = L10n.tr("Constant", "app.translation_contributor.text.nyaanim", fallback: "nyaanim") + /// PaulHaeussler + internal static let paulHaeussler = L10n.tr("Constant", "app.translation_contributor.text.paulHaeussler", fallback: "PaulHaeussler") + /// Tatsuzo Araki + internal static let tatsuz0u = L10n.tr("Constant", "app.translation_contributor.text.tatsuz0u", fallback: "Tatsuzo Araki") + } + } + } + internal enum Website { + internal enum Response { + /// This gallery has been removed or is unavailable. + internal static let galleryUnavailable = L10n.tr("Constant", "website.response.gallery_unavailable", fallback: "This gallery has been removed or is unavailable.") + /// Constant.strings + /// EhPanda + /// + /// Created by 荒木辰造 on R 4/02/04. + internal static let hathClientNotFound = L10n.tr("Constant", "website.response.hath_client_not_found", fallback: "You must have a H@H client assigned to your account to use this feature.") + /// Your H@H client appears to be offline. Turn it on, then try again. + internal static let hathClientNotOnline = L10n.tr("Constant", "website.response.hath_client_not_online", fallback: "Your H@H client appears to be offline. Turn it on, then try again.") + /// The requested gallery cannot be downloaded with the selected resolution. + internal static let invalidResolution = L10n.tr("Constant", "website.response.invalid_resolution", fallback: "The requested gallery cannot be downloaded with the selected resolution.") + } + } + } + internal enum InfoPlist { + /// InfoPlist.strings + /// EhPanda + /// + /// Created by 荒木辰造 on R 3/02/09. + internal static let nsFaceIDUsageDescription = L10n.tr("InfoPlist", "NSFaceIDUsageDescription", fallback: "We need this permission to provide Face ID option while unlocking the App.") + /// We need this permission to save images to your photo library. + internal static let nsPhotoLibraryAddUsageDescription = L10n.tr("InfoPlist", "NSPhotoLibraryAddUsageDescription", fallback: "We need this permission to save images to your photo library.") + } + internal enum Localizable { + internal enum AboutView { + internal enum Button { + /// AltStore source + internal static let altStoreSource = L10n.tr("Localizable", "about_view.button.altStore_source", fallback: "AltStore source") + /// Website + internal static let website = L10n.tr("Localizable", "about_view.button.website", fallback: "Website") + } + internal enum Section { + internal enum Title { + /// Acknowledgements + internal static let acknowledgements = L10n.tr("Localizable", "about_view.section.title.acknowledgements", fallback: "Acknowledgements") + /// Code-level contributors + internal static let codeLevelContributors = L10n.tr("Localizable", "about_view.section.title.code_level_contributors", fallback: "Code-level contributors") + /// Special thanks + internal static let specialThanks = L10n.tr("Localizable", "about_view.section.title.special_thanks", fallback: "Special thanks") + /// Translation contributors + internal static let translationContributors = L10n.tr("Localizable", "about_view.section.title.translation_contributors", fallback: "Translation contributors") + } + } + internal enum Title { + /// EhPanda + internal static let ehPanda = L10n.tr("Localizable", "about_view.title.ehPanda", fallback: "EhPanda") + /// Version + internal static let version = L10n.tr("Localizable", "about_view.title.version", fallback: "Version") + } + } + internal enum AccountSettingView { + internal enum Button { + /// Account configuration + internal static let accountConfiguration = L10n.tr("Localizable", "account_setting_view.button.account_configuration", fallback: "Account configuration") + /// Copy cookies + internal static let copyCookies = L10n.tr("Localizable", "account_setting_view.button.copy_cookies", fallback: "Copy cookies") + /// Login + internal static let login = L10n.tr("Localizable", "account_setting_view.button.login", fallback: "Login") + /// Logout + internal static let logout = L10n.tr("Localizable", "account_setting_view.button.logout", fallback: "Logout") + /// Manage tags subscription + internal static let tagsManagement = L10n.tr("Localizable", "account_setting_view.button.tags_management", fallback: "Manage tags subscription") + } + internal enum Title { + /// Account + internal static let account = L10n.tr("Localizable", "account_setting_view.title.account", fallback: "Account") + /// Shows new dawn greeting + internal static let showsNewDawnGreeting = L10n.tr("Localizable", "account_setting_view.title.shows_new_dawn_greeting", fallback: "Shows new dawn greeting") + } + } + internal enum AppIconView { + internal enum Title { + /// App icon + internal static let appIcon = L10n.tr("Localizable", "app_icon_view.title.app_icon", fallback: "App icon") + } + } + internal enum AppearanceSettingView { + internal enum Button { + /// App icon + internal static let appIcon = L10n.tr("Localizable", "appearance_setting_view.button.app_icon", fallback: "App icon") + } + internal enum Menu { + internal enum Title { + /// Infite + internal static let infite = L10n.tr("Localizable", "appearance_setting_view.menu.title.infite", fallback: "Infite") + } + } + internal enum Section { + internal enum Title { + /// Gallery + internal static let gallery = L10n.tr("Localizable", "appearance_setting_view.section.title.gallery", fallback: "Gallery") + /// List + internal static let list = L10n.tr("Localizable", "appearance_setting_view.section.title.list", fallback: "List") + } + } + internal enum Title { + /// Appearance + internal static let appearance = L10n.tr("Localizable", "appearance_setting_view.title.appearance", fallback: "Appearance") + /// Display mode + internal static let displayMode = L10n.tr("Localizable", "appearance_setting_view.title.display_mode", fallback: "Display mode") + /// Displays Japanese title + internal static let displaysJapaneseTitle = L10n.tr("Localizable", "appearance_setting_view.title.displays_japanese_title", fallback: "Displays Japanese title") + /// Maximum number of tags + internal static let maximumNumberOfTags = L10n.tr("Localizable", "appearance_setting_view.title.maximum_number_of_tags", fallback: "Maximum number of tags") + /// Shows tags in list + internal static let showsTagsInList = L10n.tr("Localizable", "appearance_setting_view.title.shows_tags_in_list", fallback: "Shows tags in list") + /// Theme + internal static let theme = L10n.tr("Localizable", "appearance_setting_view.title.theme", fallback: "Theme") + /// Tint color + internal static let tintColor = L10n.tr("Localizable", "appearance_setting_view.title.tint_color", fallback: "Tint color") + } + } + internal enum ArchivesView { + internal enum Button { + /// Download To H@H Client + internal static let downloadToHathClient = L10n.tr("Localizable", "archives_view.button.download_to_hath_client", fallback: "Download To H@H Client") + } + internal enum Title { + /// Archives + internal static let archives = L10n.tr("Localizable", "archives_view.title.archives", fallback: "Archives") + } + } + internal enum CommentsView { + internal enum Title { + /// Comments + internal static let comments = L10n.tr("Localizable", "comments_view.title.comments", fallback: "Comments") + } + } + internal enum Common { + internal enum Value { + /// %@ day + internal static func day(_ p1: Any) -> String { + return L10n.tr("Localizable", "common.value.day", String(describing: p1), fallback: "%@ day") + } + /// %@ days + internal static func days(_ p1: Any) -> String { + return L10n.tr("Localizable", "common.value.days", String(describing: p1), fallback: "%@ days") + } + /// %@ hour + internal static func hour(_ p1: Any) -> String { + return L10n.tr("Localizable", "common.value.hour", String(describing: p1), fallback: "%@ hour") + } + /// %@ hours + internal static func hours(_ p1: Any) -> String { + return L10n.tr("Localizable", "common.value.hours", String(describing: p1), fallback: "%@ hours") + } + /// %@ minute + internal static func minute(_ p1: Any) -> String { + return L10n.tr("Localizable", "common.value.minute", String(describing: p1), fallback: "%@ minute") + } + /// %@ minutes + internal static func minutes(_ p1: Any) -> String { + return L10n.tr("Localizable", "common.value.minutes", String(describing: p1), fallback: "%@ minutes") + } + /// %@ pages + internal static func pages(_ p1: Any) -> String { + return L10n.tr("Localizable", "common.value.pages", String(describing: p1), fallback: "%@ pages") + } + /// %@ records + internal static func records(_ p1: Any) -> String { + return L10n.tr("Localizable", "common.value.records", String(describing: p1), fallback: "%@ records") + } + /// %@ second + internal static func second(_ p1: Any) -> String { + return L10n.tr("Localizable", "common.value.second", String(describing: p1), fallback: "%@ second") + } + /// %@ seconds + internal static func seconds(_ p1: Any) -> String { + return L10n.tr("Localizable", "common.value.seconds", String(describing: p1), fallback: "%@ seconds") + } + /// %@ stars + internal static func stars(_ p1: Any) -> String { + return L10n.tr("Localizable", "common.value.stars", String(describing: p1), fallback: "%@ stars") + } + /// %@ times + internal static func times(_ p1: Any) -> String { + return L10n.tr("Localizable", "common.value.times", String(describing: p1), fallback: "%@ times") + } + } + } + internal enum ConfirmationDialog { + internal enum Button { + /// Clear + internal static let clear = L10n.tr("Localizable", "confirmation_dialog.button.clear", fallback: "Clear") + /// Delete + internal static let delete = L10n.tr("Localizable", "confirmation_dialog.button.delete", fallback: "Delete") + /// Drop the database + internal static let dropDatabase = L10n.tr("Localizable", "confirmation_dialog.button.drop_database", fallback: "Drop the database") + /// Logout + internal static let logout = L10n.tr("Localizable", "confirmation_dialog.button.logout", fallback: "Logout") + /// Remove + internal static let remove = L10n.tr("Localizable", "confirmation_dialog.button.remove", fallback: "Remove") + /// Reset + internal static let reset = L10n.tr("Localizable", "confirmation_dialog.button.reset", fallback: "Reset") + } + internal enum Title { + /// Are you sure to clear? + internal static let clear = L10n.tr("Localizable", "confirmation_dialog.title.clear", fallback: "Are you sure to clear?") + /// Are you sure to delete this item? + internal static let delete = L10n.tr("Localizable", "confirmation_dialog.title.delete", fallback: "Are you sure to delete this item?") + /// You will lose all your data in this app. + /// Are you sure to drop the database? + internal static let dropDatabase = L10n.tr("Localizable", "confirmation_dialog.title.drop_database", fallback: "You will lose all your data in this app.\nAre you sure to drop the database?") + /// Are you sure to logout? + internal static let logout = L10n.tr("Localizable", "confirmation_dialog.title.logout", fallback: "Are you sure to logout?") + /// Are you sure to remove your custom translations? + internal static let removeCustomTranslations = L10n.tr("Localizable", "confirmation_dialog.title.remove_custom_translations", fallback: "Are you sure to remove your custom translations?") + /// Are you sure to reset? + internal static let reset = L10n.tr("Localizable", "confirmation_dialog.title.reset", fallback: "Are you sure to reset?") + } + } + internal enum DetailView { + internal enum ActionSection { + internal enum Button { + /// Give a Rating + internal static let giveARating = L10n.tr("Localizable", "detail_view.action_section.button.give_a_rating", fallback: "Give a Rating") + /// Similar Gallery + internal static let similarGallery = L10n.tr("Localizable", "detail_view.action_section.button.similar_gallery", fallback: "Similar Gallery") + } + } + internal enum Button { + /// Post comment + internal static let postComment = L10n.tr("Localizable", "detail_view.button.post_comment", fallback: "Post comment") + /// Read + internal static let read = L10n.tr("Localizable", "detail_view.button.read", fallback: "Read") + } + internal enum ContextMenu { + internal enum Button { + /// Detail + internal static let detail = L10n.tr("Localizable", "detail_view.context_menu.button.detail", fallback: "Detail") + /// Vote down + internal static let voteDown = L10n.tr("Localizable", "detail_view.context_menu.button.vote_down", fallback: "Vote down") + /// Vote up + internal static let voteUp = L10n.tr("Localizable", "detail_view.context_menu.button.vote_up", fallback: "Vote up") + /// Withdraw vote + internal static let withdrawVote = L10n.tr("Localizable", "detail_view.context_menu.button.withdraw_vote", fallback: "Withdraw vote") + } + } + internal enum DescriptionSection { + internal enum Description { + /// Times + internal static let favorited = L10n.tr("Localizable", "detail_view.description_section.description.favorited", fallback: "Times") + /// Pages + internal static let pageCount = L10n.tr("Localizable", "detail_view.description_section.description.page_count", fallback: "Pages") + } + internal enum Title { + /// Favorited + internal static let favorited = L10n.tr("Localizable", "detail_view.description_section.title.favorited", fallback: "Favorited") + /// File Size + internal static let fileSize = L10n.tr("Localizable", "detail_view.description_section.title.file_size", fallback: "File Size") + /// Language + internal static let language = L10n.tr("Localizable", "detail_view.description_section.title.language", fallback: "Language") + /// Page Count + internal static let pageCount = L10n.tr("Localizable", "detail_view.description_section.title.page_count", fallback: "Page Count") + /// %@ Ratings + internal static func ratings(_ p1: Any) -> String { + return L10n.tr("Localizable", "detail_view.description_section.title.ratings", String(describing: p1), fallback: "%@ Ratings") + } + } + } + internal enum Section { + internal enum Title { + /// Comments + internal static let comments = L10n.tr("Localizable", "detail_view.section.title.comments", fallback: "Comments") + /// Previews + internal static let previews = L10n.tr("Localizable", "detail_view.section.title.previews", fallback: "Previews") + } + } + internal enum ToolbarItem { + internal enum Button { + /// Archives + internal static let archives = L10n.tr("Localizable", "detail_view.toolbar_item.button.archives", fallback: "Archives") + /// Share + internal static let share = L10n.tr("Localizable", "detail_view.toolbar_item.button.share", fallback: "Share") + /// Torrents + internal static let torrents = L10n.tr("Localizable", "detail_view.toolbar_item.button.torrents", fallback: "Torrents") + } + } + } + internal enum EhSettingView { + internal enum Button { + /// Create new + internal static let createNew = L10n.tr("Localizable", "eh_setting_view.button.create_new", fallback: "Create new") + /// Delete profile + internal static let deleteProfile = L10n.tr("Localizable", "eh_setting_view.button.delete_profile", fallback: "Delete profile") + /// Rename + internal static let rename = L10n.tr("Localizable", "eh_setting_view.button.rename", fallback: "Rename") + /// Set as default + internal static let setAsDefault = L10n.tr("Localizable", "eh_setting_view.button.set_as_default", fallback: "Set as default") + } + internal enum Description { + /// The default behavior for the Archiver is to confirm the cost and selection for original or resampled archive, then present a link that can be clicked or copied elsewhere. You can change this behavior here. + internal static let archiverBehavior = L10n.tr("Localizable", "eh_setting_view.description.archiver_behavior", fallback: "The default behavior for the Archiver is to confirm the cost and selection for original or resampled archive, then present a link that can be clicked or copied elsewhere. You can change this behavior here.") + /// You appear to be browsing the site from **%@** or use a VPN or proxy in this country, which means the site will try to load images from H@H clients in this general geographic region. If this is incorrect, or if you want to use a different region for any reason (like if you are using a split tunneling VPN), you can select a different country below. + internal static func browsingCountry(_ p1: Any) -> String { + return L10n.tr("Localizable", "eh_setting_view.description.browsing_country", String(describing: p1), fallback: "You appear to be browsing the site from **%@** or use a VPN or proxy in this country, which means the site will try to load images from H@H clients in this general geographic region. If this is incorrect, or if you want to use a different region for any reason (like if you are using a split tunneling VPN), you can select a different country below.") + } + /// Which display mode would you like to use on the front and search pages? + internal static let displayMode = L10n.tr("Localizable", "eh_setting_view.description.display_mode", fallback: "Which display mode would you like to use on the front and search pages?") + /// If you wish to hide galleries in certain languages from the gallery list and searches, select them from the list below. Note that matching galleries will never appear regardless of your search query. + internal static let excludedLanguages = L10n.tr("Localizable", "eh_setting_view.description.excluded_languages", fallback: "If you wish to hide galleries in certain languages from the gallery list and searches, select them from the list below. Note that matching galleries will never appear regardless of your search query.") + /// If you wish to hide galleries from certain uploaders from the gallery list and searches, add them below. Put one username per line. Note that galleries from these uploaders will never appear regardless of your search query. + internal static let excludedUploaders = L10n.tr("Localizable", "eh_setting_view.description.excluded_uploaders", fallback: "If you wish to hide galleries from certain uploaders from the gallery list and searches, add them below. Put one username per line. Note that galleries from these uploaders will never appear regardless of your search query.") + /// You are currently using **%@ / %@** exclusion slots. + internal static func excludedUploadersCount(_ p1: Any, _ p2: Any) -> String { + return L10n.tr("Localizable", "eh_setting_view.description.excluded_uploaders_count", String(describing: p1), String(describing: p2), fallback: "You are currently using **%@ / %@** exclusion slots.") + } + /// Here you can choose and rename your favorite categories. + internal static let favoriteCategories = L10n.tr("Localizable", "eh_setting_view.description.favorite_categories", fallback: "Here you can choose and rename your favorite categories.") + /// You can also select your default sort order for galleries on your favorites page. Note that favorites added prior to the March 2016 revamp did not store a timestamp, and will use the gallery posted time regardless of this setting. + internal static let favoritesSortOrder = L10n.tr("Localizable", "eh_setting_view.description.favorites_sort_order", fallback: "You can also select your default sort order for galleries on your favorites page. Note that favorites added prior to the March 2016 revamp did not store a timestamp, and will use the gallery posted time regardless of this setting.") + /// Show the "Your default filters removed XX galleries from this page" readout? + internal static let filteredRemovalCount = L10n.tr("Localizable", "eh_setting_view.description.filtered_removal_count", fallback: "Show the \"Your default filters removed XX galleries from this page\" readout?") + /// What categories would you like to show by default on the front page and in searches? + internal static let galleryCategory = L10n.tr("Localizable", "eh_setting_view.description.gallery_category", fallback: "What categories would you like to show by default on the front page and in searches?") + /// Many galleries have both an English/Romanized title and a title in Japanese script. Which gallery name would you like as default? + internal static let galleryName = L10n.tr("Localizable", "eh_setting_view.description.gallery_name", fallback: "Many galleries have both an English/Romanized title and a title in Japanese script. Which gallery name would you like as default?") + /// Normally, images are resampled to 1280 pixels of horizontal resolution for online viewing. You can alternatively select one of the following resample resolutions. To avoid murdering the staging servers, resolutions above 1280x are temporarily restricted to donators, people with any hath perk, and people with a UID below 3,000,000. + internal static let imageResolution = L10n.tr("Localizable", "eh_setting_view.description.image_resolution", fallback: "Normally, images are resampled to 1280 pixels of horizontal resolution for online viewing. You can alternatively select one of the following resample resolutions. To avoid murdering the staging servers, resolutions above 1280x are temporarily restricted to donators, people with any hath perk, and people with a UID below 3,000,000.") + /// While the site will automatically scale down images to fit your screen width, you can also manually restrict the maximum display size of an image. Like the automatic scaling, this does not resample the image, as the resizing is done browser-side. (0 = no limit) + internal static let imageSize = L10n.tr("Localizable", "eh_setting_view.description.image_size", fallback: "While the site will automatically scale down images to fit your screen width, you can also manually restrict the maximum display size of an image. Like the automatic scaling, this does not resample the image, as the resizing is done browser-side. (0 = no limit)") + /// This setting can be used if you have a H@H client running on your local network with the same public IP you browse the site with. Some routers are buggy and cannot route requests back to its own IP; this allows you to work around this problem. + /// If you are running the client on the same device you browse from, use the loopback address (127.0.0.1:port). If the client is running on another device on your network, use its local network IP. Some browser configurations prevent external web sites from accessing URLs with local network IPs, the site must then be whitelisted for this to work. + internal static let ipAddressPort = L10n.tr("Localizable", "eh_setting_view.description.ip_address_port", fallback: "This setting can be used if you have a H@H client running on your local network with the same public IP you browse the site with. Some routers are buggy and cannot route requests back to its own IP; this allows you to work around this problem.\nIf you are running the client on the same device you browse from, use the loopback address (127.0.0.1:port). If the client is running on another device on your network, use its local network IP. Some browser configurations prevent external web sites from accessing URLs with local network IPs, the site must then be whitelisted for this to work.") + /// By default, galleries that you have rated will appear with red stars for ratings of 2 stars and below, green for ratings between 2.5 and 4 stars, and blue for ratings of 4.5 or 5 stars. You can customize this by entering your desired color combination below. Each letter represents one star. The default RRGGB means R(ed) for the first and second star, G(reen) for the third and fourth, and B(lue) for the fifth. You can also use (Y)ellow for the normal stars. Any five-letter R/G/B/Y combo works. + internal static let ratingsColor = L10n.tr("Localizable", "eh_setting_view.description.ratings_color", fallback: "By default, galleries that you have rated will appear with red stars for ratings of 2 stars and below, green for ratings between 2.5 and 4 stars, and blue for ratings of 4.5 or 5 stars. You can customize this by entering your desired color combination below. Each letter represents one star. The default RRGGB means R(ed) for the first and second star, G(reen) for the third and fourth, and B(lue) for the fifth. You can also use (Y)ellow for the normal stars. Any five-letter R/G/B/Y combo works.") + /// How many results would you like per page for the index/search page and torrent search pages? + /// (Hath Perk: Paging Enlargement Required) + internal static let resultCount = L10n.tr("Localizable", "eh_setting_view.description.result_count", fallback: "How many results would you like per page for the index/search page and torrent search pages?\n(Hath Perk: Paging Enlargement Required)") + /// Thumbnails on the thumbnail and extended gallery list views can be scaled to a custom value between 75%% and 150%%. + internal static let scaleFactor = L10n.tr("Localizable", "eh_setting_view.description.scale_factor", fallback: "Thumbnails on the thumbnail and extended gallery list views can be scaled to a custom value between 75%% and 150%%.") + /// You can soft filter tags by adding them to My Tags with a negative weight. If a gallery has tags that add up to weight below this value, it is filtered from view. This threshold can be set between 0 and -9999. + internal static let tagFilteringThreshold = L10n.tr("Localizable", "eh_setting_view.description.tag_filtering_threshold", fallback: "You can soft filter tags by adding them to My Tags with a negative weight. If a gallery has tags that add up to weight below this value, it is filtered from view. This threshold can be set between 0 and -9999.") + /// Recently uploaded galleries will be included on the watched screen if it has at least one watched tag with positive weight, and the sum of weights on its watched tags add up to this value or higher. This threshold can be set between 0 and 9999. + internal static let tagWatchingThreshold = L10n.tr("Localizable", "eh_setting_view.description.tag_watching_threshold", fallback: "Recently uploaded galleries will be included on the watched screen if it has at least one watched tag with positive weight, and the sum of weights on its watched tags add up to this value or higher. This threshold can be set between 0 and 9999.") + /// You can set a default thumbnail configuration for all galleries you visit. + internal static let thumbnailConfiguration = L10n.tr("Localizable", "eh_setting_view.description.thumbnail_configuration", fallback: "You can set a default thumbnail configuration for all galleries you visit.") + /// How would you like the mouse-over thumbnails on the front page to load when using List Mode? + internal static let thumbnailLoadTiming = L10n.tr("Localizable", "eh_setting_view.description.thumbnail_load_timing", fallback: "How would you like the mouse-over thumbnails on the front page to load when using List Mode?") + /// Allows you to override the virtual width of the site for mobile devices. This is normally determined automatically by your device based on its DPI. Sensible values at 100%% thumbnail scale are between 640 and 1400. + internal static let virtualWidth = L10n.tr("Localizable", "eh_setting_view.description.virtual_width", fallback: "Allows you to override the virtual width of the site for mobile devices. This is normally determined automatically by your device based on its DPI. Sensible values at 100%% thumbnail scale are between 640 and 1400.") + } + internal enum Promt { + /// RRGGB + internal static let ratingsColor = L10n.tr("Localizable", "eh_setting_view.promt.ratings_color", fallback: "RRGGB") + } + internal enum Section { + internal enum Title { + /// Archiver Settings + internal static let archiverSettings = L10n.tr("Localizable", "eh_setting_view.section.title.archiver_settings", fallback: "Archiver Settings") + /// Excluded Languages + internal static let excludedLanguages = L10n.tr("Localizable", "eh_setting_view.section.title.excluded_languages", fallback: "Excluded Languages") + /// Excluded Uploaders + internal static let excludedUploaders = L10n.tr("Localizable", "eh_setting_view.section.title.excluded_uploaders", fallback: "Excluded Uploaders") + /// Favorites + internal static let favorites = L10n.tr("Localizable", "eh_setting_view.section.title.favorites", fallback: "Favorites") + /// Show Filtered Removal Count + internal static let filteredRemovalCount = L10n.tr("Localizable", "eh_setting_view.section.title.filtered_removal_count", fallback: "Show Filtered Removal Count") + /// Front Page Settings + internal static let frontPageSettings = L10n.tr("Localizable", "eh_setting_view.section.title.front_page_settings", fallback: "Front Page Settings") + /// Gallery Comments + internal static let galleryComments = L10n.tr("Localizable", "eh_setting_view.section.title.gallery_comments", fallback: "Gallery Comments") + /// Gallery Name Display + internal static let galleryNameDisplay = L10n.tr("Localizable", "eh_setting_view.section.title.gallery_name_display", fallback: "Gallery Name Display") + /// Gallery Page Numbering + internal static let galleryPageNumbering = L10n.tr("Localizable", "eh_setting_view.section.title.gallery_page_numbering", fallback: "Gallery Page Numbering") + /// Gallery Tags + internal static let galleryTags = L10n.tr("Localizable", "eh_setting_view.section.title.gallery_tags", fallback: "Gallery Tags") + /// Hath Local Network Host + internal static let hathLocalNetworkHost = L10n.tr("Localizable", "eh_setting_view.section.title.hath_local_network_host", fallback: "Hath Local Network Host") + /// Image Load Settings + internal static let imageLoadSettings = L10n.tr("Localizable", "eh_setting_view.section.title.image_load_settings", fallback: "Image Load Settings") + /// Image Size Settings + internal static let imageSizeSettings = L10n.tr("Localizable", "eh_setting_view.section.title.image_size_settings", fallback: "Image Size Settings") + /// Multi-Page Viewer + internal static let multiPageViewer = L10n.tr("Localizable", "eh_setting_view.section.title.multi_page_viewer", fallback: "Multi-Page Viewer") + /// Original Images + internal static let originalImages = L10n.tr("Localizable", "eh_setting_view.section.title.original_images", fallback: "Original Images") + /// Profile Settings + internal static let profileSettings = L10n.tr("Localizable", "eh_setting_view.section.title.profile_settings", fallback: "Profile Settings") + /// Ratings + internal static let ratings = L10n.tr("Localizable", "eh_setting_view.section.title.ratings", fallback: "Ratings") + /// Search Result Count + internal static let searchResultCount = L10n.tr("Localizable", "eh_setting_view.section.title.search_result_count", fallback: "Search Result Count") + /// Search Range Indicator + internal static let showSearchRangeIndicator = L10n.tr("Localizable", "eh_setting_view.section.title.show_search_range_indicator", fallback: "Search Range Indicator") + /// Tag Filtering Threshold + internal static let tagFilteringThreshold = L10n.tr("Localizable", "eh_setting_view.section.title.tag_filtering_threshold", fallback: "Tag Filtering Threshold") + /// Tag Watching Threshold + internal static let tagWatchingThreshold = L10n.tr("Localizable", "eh_setting_view.section.title.tag_watching_threshold", fallback: "Tag Watching Threshold") + /// Thumbnail Scaling + internal static let thumbnailScaling = L10n.tr("Localizable", "eh_setting_view.section.title.thumbnail_scaling", fallback: "Thumbnail Scaling") + /// Thumbnail Settings + internal static let thumbnailSettings = L10n.tr("Localizable", "eh_setting_view.section.title.thumbnail_settings", fallback: "Thumbnail Settings") + /// Viewport Override + internal static let viewportOverride = L10n.tr("Localizable", "eh_setting_view.section.title.viewport_override", fallback: "Viewport Override") + } + } + internal enum Title { + /// Archiver behavior + internal static let archiverBehavior = L10n.tr("Localizable", "eh_setting_view.title.archiver_behavior", fallback: "Archiver behavior") + /// Browsing country + internal static let browsingCountry = L10n.tr("Localizable", "eh_setting_view.title.browsing_country", fallback: "Browsing country") + /// Comments sort order + internal static let commentsSortOrder = L10n.tr("Localizable", "eh_setting_view.title.comments_sort_order", fallback: "Comments sort order") + /// Comment votes show timing + internal static let commentsVotesShowTiming = L10n.tr("Localizable", "eh_setting_view.title.comments_votes_show_timing", fallback: "Comment votes show timing") + /// Display mode + internal static let displayMode = L10n.tr("Localizable", "eh_setting_view.title.display_mode", fallback: "Display mode") + /// Display style + internal static let displayStyle = L10n.tr("Localizable", "eh_setting_view.title.display_style", fallback: "Display style") + /// Favorites sort order + internal static let favoritesSortOrder = L10n.tr("Localizable", "eh_setting_view.title.favorites_sort_order", fallback: "Favorites sort order") + /// Gallery name + internal static let galleryName = L10n.tr("Localizable", "eh_setting_view.title.gallery_name", fallback: "Gallery name") + /// Horizontal + internal static let horizontal = L10n.tr("Localizable", "eh_setting_view.title.horizontal", fallback: "Horizontal") + /// %@ settings + internal static func hostSettings(_ p1: Any) -> String { + return L10n.tr("Localizable", "eh_setting_view.title.host_settings", String(describing: p1), fallback: "%@ settings") + } + /// Image resolution + internal static let imageResolution = L10n.tr("Localizable", "eh_setting_view.title.image_resolution", fallback: "Image resolution") + /// Image size + internal static let imageSize = L10n.tr("Localizable", "eh_setting_view.title.image_size", fallback: "Image size") + /// IP address:Port + internal static let ipAddressPort = L10n.tr("Localizable", "eh_setting_view.title.ip_address_port", fallback: "IP address:Port") + /// Load images through the Hath network + internal static let loadImagesThroughTheHathNetwork = L10n.tr("Localizable", "eh_setting_view.title.load_images_through_the_hath_network", fallback: "Load images through the Hath network") + /// Ratings color + internal static let ratingsColor = L10n.tr("Localizable", "eh_setting_view.title.ratings_color", fallback: "Ratings color") + /// Result count + internal static let resultCount = L10n.tr("Localizable", "eh_setting_view.title.result_count", fallback: "Result count") + /// Scale factor + internal static let scaleFactor = L10n.tr("Localizable", "eh_setting_view.title.scale_factor", fallback: "Scale factor") + /// Selected profile + internal static let selectedProfile = L10n.tr("Localizable", "eh_setting_view.title.selected_profile", fallback: "Selected profile") + /// Show filtered removal count + internal static let showFilteredRemovalCount = L10n.tr("Localizable", "eh_setting_view.title.show_filtered_removal_count", fallback: "Show filtered removal count") + /// Show gallery page numbers + internal static let showGalleryPageNumbers = L10n.tr("Localizable", "eh_setting_view.title.show_gallery_page_numbers", fallback: "Show gallery page numbers") + /// Show search range indicator + internal static let showSearchRangeIndicator = L10n.tr("Localizable", "eh_setting_view.title.show_search_range_indicator", fallback: "Show search range indicator") + /// Show thumbnail pane + internal static let showThumbnailPane = L10n.tr("Localizable", "eh_setting_view.title.show_thumbnail_pane", fallback: "Show thumbnail pane") + /// Tag Filtering Threshold + internal static let tagFilteringThreshold = L10n.tr("Localizable", "eh_setting_view.title.tag_filtering_threshold", fallback: "Tag Filtering Threshold") + /// Tag Watching Threshold + internal static let tagWatchingThreshold = L10n.tr("Localizable", "eh_setting_view.title.tag_watching_threshold", fallback: "Tag Watching Threshold") + /// Tags sort order + internal static let tagsSortOrder = L10n.tr("Localizable", "eh_setting_view.title.tags_sort_order", fallback: "Tags sort order") + /// Thumbnail load timing + internal static let thumbnailLoadTiming = L10n.tr("Localizable", "eh_setting_view.title.thumbnail_load_timing", fallback: "Thumbnail load timing") + /// Rows + internal static let thumbnailRowCount = L10n.tr("Localizable", "eh_setting_view.title.thumbnail_row_count", fallback: "Rows") + /// Size + internal static let thumbnailSize = L10n.tr("Localizable", "eh_setting_view.title.thumbnail_size", fallback: "Size") + /// Use Multi-Page Viewer + internal static let useMultiPageViewer = L10n.tr("Localizable", "eh_setting_view.title.use_multi_page_viewer", fallback: "Use Multi-Page Viewer") + /// Use original images + internal static let useOriginalImages = L10n.tr("Localizable", "eh_setting_view.title.use_original_images", fallback: "Use original images") + /// Vertical + internal static let vertical = L10n.tr("Localizable", "eh_setting_view.title.vertical", fallback: "Vertical") + /// Virtual width + internal static let virtualWidth = L10n.tr("Localizable", "eh_setting_view.title.virtual_width", fallback: "Virtual width") + } + internal enum ToolbarItem { + internal enum Button { + /// Done + internal static let done = L10n.tr("Localizable", "eh_setting_view.toolbar_item.button.done", fallback: "Done") + } + } + } + internal enum Enum { + internal enum AppIconType { + internal enum Value { + /// Default + internal static let `default` = L10n.tr("Localizable", "enum.app_icon_type.value.default", fallback: "Default") + /// Developer + internal static let developer = L10n.tr("Localizable", "enum.app_icon_type.value.developer", fallback: "Developer") + /// NOT MY PRESIDENT + internal static let notMyPresident = L10n.tr("Localizable", "enum.app_icon_type.value.not_my_president", fallback: "NOT MY PRESIDENT") + /// Stand With Ukraine (2022) + internal static let standWithUkraine2022 = L10n.tr("Localizable", "enum.app_icon_type.value.stand_with_ukraine_2022", fallback: "Stand With Ukraine (2022)") + /// Ukiyo-e + internal static let ukiyoe = L10n.tr("Localizable", "enum.app_icon_type.value.ukiyoe", fallback: "Ukiyo-e") + } + } + internal enum ArchiveResolution { + internal enum Value { + /// Original + internal static let original = L10n.tr("Localizable", "enum.archive_resolution.value.original", fallback: "Original") + } + } + internal enum AutoLockPolicy { + internal enum Value { + /// Instantly + internal static let instantly = L10n.tr("Localizable", "enum.auto_lock_policy.value.instantly", fallback: "Instantly") + /// Never + internal static let never = L10n.tr("Localizable", "enum.auto_lock_policy.value.never", fallback: "Never") + } + } + internal enum AutoPlayPolicy { + internal enum Value { + /// Off + internal static let off = L10n.tr("Localizable", "enum.auto_play_policy.value.off", fallback: "Off") + } + } + internal enum BanInterval { + internal enum Description { + /// Localizable.strings + /// EhPanda + /// + /// Created by 荒木辰造 on R 2/12/25. + internal static let and = L10n.tr("Localizable", "enum.ban_interval.description.and", fallback: "and") + } + } + internal enum BrowsingCountry { + internal enum Name { + /// Afghanistan + internal static let afghanistan = L10n.tr("Localizable", "enum.browsing_country.name.afghanistan", fallback: "Afghanistan") + /// Aland Islands + internal static let alandIslands = L10n.tr("Localizable", "enum.browsing_country.name.aland_islands", fallback: "Aland Islands") + /// Albania + internal static let albania = L10n.tr("Localizable", "enum.browsing_country.name.albania", fallback: "Albania") + /// Algeria + internal static let algeria = L10n.tr("Localizable", "enum.browsing_country.name.algeria", fallback: "Algeria") + /// American Samoa + internal static let americanSamoa = L10n.tr("Localizable", "enum.browsing_country.name.american_samoa", fallback: "American Samoa") + /// Andorra + internal static let andorra = L10n.tr("Localizable", "enum.browsing_country.name.andorra", fallback: "Andorra") + /// Angola + internal static let angola = L10n.tr("Localizable", "enum.browsing_country.name.angola", fallback: "Angola") + /// Anguilla + internal static let anguilla = L10n.tr("Localizable", "enum.browsing_country.name.anguilla", fallback: "Anguilla") + /// Antarctica + internal static let antarctica = L10n.tr("Localizable", "enum.browsing_country.name.antarctica", fallback: "Antarctica") + /// Antigua and Barbuda + internal static let antiguaAndBarbuda = L10n.tr("Localizable", "enum.browsing_country.name.antigua_and_barbuda", fallback: "Antigua and Barbuda") + /// Argentina + internal static let argentina = L10n.tr("Localizable", "enum.browsing_country.name.argentina", fallback: "Argentina") + /// Armenia + internal static let armenia = L10n.tr("Localizable", "enum.browsing_country.name.armenia", fallback: "Armenia") + /// Aruba + internal static let aruba = L10n.tr("Localizable", "enum.browsing_country.name.aruba", fallback: "Aruba") + /// Asia-Pacific Region + internal static let asiaPacificRegion = L10n.tr("Localizable", "enum.browsing_country.name.asia_pacific_region", fallback: "Asia-Pacific Region") + /// Australia + internal static let australia = L10n.tr("Localizable", "enum.browsing_country.name.australia", fallback: "Australia") + /// Austria + internal static let austria = L10n.tr("Localizable", "enum.browsing_country.name.austria", fallback: "Austria") + /// Auto-Detect + internal static let autoDetect = L10n.tr("Localizable", "enum.browsing_country.name.auto_detect", fallback: "Auto-Detect") + /// Azerbaijan + internal static let azerbaijan = L10n.tr("Localizable", "enum.browsing_country.name.azerbaijan", fallback: "Azerbaijan") + /// Bahamas + internal static let bahamas = L10n.tr("Localizable", "enum.browsing_country.name.bahamas", fallback: "Bahamas") + /// Bahrain + internal static let bahrain = L10n.tr("Localizable", "enum.browsing_country.name.bahrain", fallback: "Bahrain") + /// Bangladesh + internal static let bangladesh = L10n.tr("Localizable", "enum.browsing_country.name.bangladesh", fallback: "Bangladesh") + /// Barbados + internal static let barbados = L10n.tr("Localizable", "enum.browsing_country.name.barbados", fallback: "Barbados") + /// Belarus + internal static let belarus = L10n.tr("Localizable", "enum.browsing_country.name.belarus", fallback: "Belarus") + /// Belgium + internal static let belgium = L10n.tr("Localizable", "enum.browsing_country.name.belgium", fallback: "Belgium") + /// Belize + internal static let belize = L10n.tr("Localizable", "enum.browsing_country.name.belize", fallback: "Belize") + /// Benin + internal static let benin = L10n.tr("Localizable", "enum.browsing_country.name.benin", fallback: "Benin") + /// Bermuda + internal static let bermuda = L10n.tr("Localizable", "enum.browsing_country.name.bermuda", fallback: "Bermuda") + /// Bhutan + internal static let bhutan = L10n.tr("Localizable", "enum.browsing_country.name.bhutan", fallback: "Bhutan") + /// Bolivia + internal static let bolivia = L10n.tr("Localizable", "enum.browsing_country.name.bolivia", fallback: "Bolivia") + /// Bonaire Saint Eustatius and Saba + internal static let bonaireSaintEustatiusAndSaba = L10n.tr("Localizable", "enum.browsing_country.name.bonaire_saint_eustatius_and_saba", fallback: "Bonaire Saint Eustatius and Saba") + /// Bosnia and Herzegovina + internal static let bosniaAndHerzegovina = L10n.tr("Localizable", "enum.browsing_country.name.bosnia_and_herzegovina", fallback: "Bosnia and Herzegovina") + /// Botswana + internal static let botswana = L10n.tr("Localizable", "enum.browsing_country.name.botswana", fallback: "Botswana") + /// Bouvet Island + internal static let bouvetIsland = L10n.tr("Localizable", "enum.browsing_country.name.bouvet_island", fallback: "Bouvet Island") + /// Brazil + internal static let brazil = L10n.tr("Localizable", "enum.browsing_country.name.brazil", fallback: "Brazil") + /// British Indian Ocean Territory + internal static let britishIndianOceanTerritory = L10n.tr("Localizable", "enum.browsing_country.name.british_indian_ocean_territory", fallback: "British Indian Ocean Territory") + /// Brunei Darussalam + internal static let bruneiDarussalam = L10n.tr("Localizable", "enum.browsing_country.name.brunei_darussalam", fallback: "Brunei Darussalam") + /// Bulgaria + internal static let bulgaria = L10n.tr("Localizable", "enum.browsing_country.name.bulgaria", fallback: "Bulgaria") + /// Burkina Faso + internal static let burkinaFaso = L10n.tr("Localizable", "enum.browsing_country.name.burkina_faso", fallback: "Burkina Faso") + /// Burundi + internal static let burundi = L10n.tr("Localizable", "enum.browsing_country.name.burundi", fallback: "Burundi") + /// Cambodia + internal static let cambodia = L10n.tr("Localizable", "enum.browsing_country.name.cambodia", fallback: "Cambodia") + /// Cameroon + internal static let cameroon = L10n.tr("Localizable", "enum.browsing_country.name.cameroon", fallback: "Cameroon") + /// Canada + internal static let canada = L10n.tr("Localizable", "enum.browsing_country.name.canada", fallback: "Canada") + /// Cape Verde + internal static let capeVerde = L10n.tr("Localizable", "enum.browsing_country.name.cape_verde", fallback: "Cape Verde") + /// Cayman Islands + internal static let caymanIslands = L10n.tr("Localizable", "enum.browsing_country.name.cayman_islands", fallback: "Cayman Islands") + /// Central African Republic + internal static let centralAfricanRepublic = L10n.tr("Localizable", "enum.browsing_country.name.central_african_republic", fallback: "Central African Republic") + /// Chad + internal static let chad = L10n.tr("Localizable", "enum.browsing_country.name.chad", fallback: "Chad") + /// Chile + internal static let chile = L10n.tr("Localizable", "enum.browsing_country.name.chile", fallback: "Chile") + /// China + internal static let china = L10n.tr("Localizable", "enum.browsing_country.name.china", fallback: "China") + /// Christmas Island + internal static let christmasIsland = L10n.tr("Localizable", "enum.browsing_country.name.christmas_island", fallback: "Christmas Island") + /// Cocos Islands + internal static let cocosIslands = L10n.tr("Localizable", "enum.browsing_country.name.cocos_islands", fallback: "Cocos Islands") + /// Colombia + internal static let colombia = L10n.tr("Localizable", "enum.browsing_country.name.colombia", fallback: "Colombia") + /// Comoros + internal static let comoros = L10n.tr("Localizable", "enum.browsing_country.name.comoros", fallback: "Comoros") + /// Congo + internal static let congo = L10n.tr("Localizable", "enum.browsing_country.name.congo", fallback: "Congo") + /// Cook Islands + internal static let cookIslands = L10n.tr("Localizable", "enum.browsing_country.name.cook_islands", fallback: "Cook Islands") + /// Costa Rica + internal static let costaRica = L10n.tr("Localizable", "enum.browsing_country.name.costa_rica", fallback: "Costa Rica") + /// Cote D'Ivoire + internal static let coteDIvoire = L10n.tr("Localizable", "enum.browsing_country.name.cote_d_ivoire", fallback: "Cote D'Ivoire") + /// Croatia + internal static let croatia = L10n.tr("Localizable", "enum.browsing_country.name.croatia", fallback: "Croatia") + /// Cuba + internal static let cuba = L10n.tr("Localizable", "enum.browsing_country.name.cuba", fallback: "Cuba") + /// Curacao + internal static let curacao = L10n.tr("Localizable", "enum.browsing_country.name.curacao", fallback: "Curacao") + /// Cyprus + internal static let cyprus = L10n.tr("Localizable", "enum.browsing_country.name.cyprus", fallback: "Cyprus") + /// Czech Republic + internal static let czechRepublic = L10n.tr("Localizable", "enum.browsing_country.name.czech_republic", fallback: "Czech Republic") + /// Denmark + internal static let denmark = L10n.tr("Localizable", "enum.browsing_country.name.denmark", fallback: "Denmark") + /// Djibouti + internal static let djibouti = L10n.tr("Localizable", "enum.browsing_country.name.djibouti", fallback: "Djibouti") + /// Dominica + internal static let dominica = L10n.tr("Localizable", "enum.browsing_country.name.dominica", fallback: "Dominica") + /// Dominican Republic + internal static let dominicanRepublic = L10n.tr("Localizable", "enum.browsing_country.name.dominican_republic", fallback: "Dominican Republic") + /// Ecuador + internal static let ecuador = L10n.tr("Localizable", "enum.browsing_country.name.ecuador", fallback: "Ecuador") + /// Egypt + internal static let egypt = L10n.tr("Localizable", "enum.browsing_country.name.egypt", fallback: "Egypt") + /// El Salvador + internal static let elSalvador = L10n.tr("Localizable", "enum.browsing_country.name.el_salvador", fallback: "El Salvador") + /// Equatorial Guinea + internal static let equatorialGuinea = L10n.tr("Localizable", "enum.browsing_country.name.equatorial_guinea", fallback: "Equatorial Guinea") + /// Eritrea + internal static let eritrea = L10n.tr("Localizable", "enum.browsing_country.name.eritrea", fallback: "Eritrea") + /// Estonia + internal static let estonia = L10n.tr("Localizable", "enum.browsing_country.name.estonia", fallback: "Estonia") + /// Ethiopia + internal static let ethiopia = L10n.tr("Localizable", "enum.browsing_country.name.ethiopia", fallback: "Ethiopia") + /// Europe + internal static let europe = L10n.tr("Localizable", "enum.browsing_country.name.europe", fallback: "Europe") + /// Falkland Islands + internal static let falklandIslands = L10n.tr("Localizable", "enum.browsing_country.name.falkland_islands", fallback: "Falkland Islands") + /// Faroe Islands + internal static let faroeIslands = L10n.tr("Localizable", "enum.browsing_country.name.faroe_islands", fallback: "Faroe Islands") + /// Fiji + internal static let fiji = L10n.tr("Localizable", "enum.browsing_country.name.fiji", fallback: "Fiji") + /// Finland + internal static let finland = L10n.tr("Localizable", "enum.browsing_country.name.finland", fallback: "Finland") + /// France + internal static let france = L10n.tr("Localizable", "enum.browsing_country.name.france", fallback: "France") + /// French Guiana + internal static let frenchGuiana = L10n.tr("Localizable", "enum.browsing_country.name.french_guiana", fallback: "French Guiana") + /// French Polynesia + internal static let frenchPolynesia = L10n.tr("Localizable", "enum.browsing_country.name.french_polynesia", fallback: "French Polynesia") + /// French Southern Territories + internal static let frenchSouthernTerritories = L10n.tr("Localizable", "enum.browsing_country.name.french_southern_territories", fallback: "French Southern Territories") + /// Gabon + internal static let gabon = L10n.tr("Localizable", "enum.browsing_country.name.gabon", fallback: "Gabon") + /// Gambia + internal static let gambia = L10n.tr("Localizable", "enum.browsing_country.name.gambia", fallback: "Gambia") + /// Georgia + internal static let georgia = L10n.tr("Localizable", "enum.browsing_country.name.georgia", fallback: "Georgia") + /// Germany + internal static let germany = L10n.tr("Localizable", "enum.browsing_country.name.germany", fallback: "Germany") + /// Ghana + internal static let ghana = L10n.tr("Localizable", "enum.browsing_country.name.ghana", fallback: "Ghana") + /// Gibraltar + internal static let gibraltar = L10n.tr("Localizable", "enum.browsing_country.name.gibraltar", fallback: "Gibraltar") + /// Greece + internal static let greece = L10n.tr("Localizable", "enum.browsing_country.name.greece", fallback: "Greece") + /// Greenland + internal static let greenland = L10n.tr("Localizable", "enum.browsing_country.name.greenland", fallback: "Greenland") + /// Grenada + internal static let grenada = L10n.tr("Localizable", "enum.browsing_country.name.grenada", fallback: "Grenada") + /// Guadeloupe + internal static let guadeloupe = L10n.tr("Localizable", "enum.browsing_country.name.guadeloupe", fallback: "Guadeloupe") + /// Guam + internal static let guam = L10n.tr("Localizable", "enum.browsing_country.name.guam", fallback: "Guam") + /// Guatemala + internal static let guatemala = L10n.tr("Localizable", "enum.browsing_country.name.guatemala", fallback: "Guatemala") + /// Guernsey + internal static let guernsey = L10n.tr("Localizable", "enum.browsing_country.name.guernsey", fallback: "Guernsey") + /// Guinea + internal static let guinea = L10n.tr("Localizable", "enum.browsing_country.name.guinea", fallback: "Guinea") + /// Guinea-Bissau + internal static let guineaBissau = L10n.tr("Localizable", "enum.browsing_country.name.guinea_bissau", fallback: "Guinea-Bissau") + /// Guyana + internal static let guyana = L10n.tr("Localizable", "enum.browsing_country.name.guyana", fallback: "Guyana") + /// Haiti + internal static let haiti = L10n.tr("Localizable", "enum.browsing_country.name.haiti", fallback: "Haiti") + /// Heard Island and McDonald Islands + internal static let heardIslandAndMcDonaldIslands = L10n.tr("Localizable", "enum.browsing_country.name.heard_island_and_mc_donald_islands", fallback: "Heard Island and McDonald Islands") + /// Honduras + internal static let honduras = L10n.tr("Localizable", "enum.browsing_country.name.honduras", fallback: "Honduras") + /// Hong Kong + internal static let hongKong = L10n.tr("Localizable", "enum.browsing_country.name.hong_kong", fallback: "Hong Kong") + /// Hungary + internal static let hungary = L10n.tr("Localizable", "enum.browsing_country.name.hungary", fallback: "Hungary") + /// Iceland + internal static let iceland = L10n.tr("Localizable", "enum.browsing_country.name.iceland", fallback: "Iceland") + /// India + internal static let india = L10n.tr("Localizable", "enum.browsing_country.name.india", fallback: "India") + /// Indonesia + internal static let indonesia = L10n.tr("Localizable", "enum.browsing_country.name.indonesia", fallback: "Indonesia") + /// Iran + internal static let iran = L10n.tr("Localizable", "enum.browsing_country.name.iran", fallback: "Iran") + /// Iraq + internal static let iraq = L10n.tr("Localizable", "enum.browsing_country.name.iraq", fallback: "Iraq") + /// Ireland + internal static let ireland = L10n.tr("Localizable", "enum.browsing_country.name.ireland", fallback: "Ireland") + /// Isle of Man + internal static let isleOfMan = L10n.tr("Localizable", "enum.browsing_country.name.isle_of_man", fallback: "Isle of Man") + /// Israel + internal static let israel = L10n.tr("Localizable", "enum.browsing_country.name.israel", fallback: "Israel") + /// Italy + internal static let italy = L10n.tr("Localizable", "enum.browsing_country.name.italy", fallback: "Italy") + /// Jamaica + internal static let jamaica = L10n.tr("Localizable", "enum.browsing_country.name.jamaica", fallback: "Jamaica") + /// Japan + internal static let japan = L10n.tr("Localizable", "enum.browsing_country.name.japan", fallback: "Japan") + /// Jersey + internal static let jersey = L10n.tr("Localizable", "enum.browsing_country.name.jersey", fallback: "Jersey") + /// Jordan + internal static let jordan = L10n.tr("Localizable", "enum.browsing_country.name.jordan", fallback: "Jordan") + /// Kazakhstan + internal static let kazakhstan = L10n.tr("Localizable", "enum.browsing_country.name.kazakhstan", fallback: "Kazakhstan") + /// Kenya + internal static let kenya = L10n.tr("Localizable", "enum.browsing_country.name.kenya", fallback: "Kenya") + /// Kiribati + internal static let kiribati = L10n.tr("Localizable", "enum.browsing_country.name.kiribati", fallback: "Kiribati") + /// Kuwait + internal static let kuwait = L10n.tr("Localizable", "enum.browsing_country.name.kuwait", fallback: "Kuwait") + /// Kyrgyzstan + internal static let kyrgyzstan = L10n.tr("Localizable", "enum.browsing_country.name.kyrgyzstan", fallback: "Kyrgyzstan") + /// Lao People's Democratic Republic + internal static let laoPeoplesDemocraticRepublic = L10n.tr("Localizable", "enum.browsing_country.name.lao_peoples_democratic_republic", fallback: "Lao People's Democratic Republic") + /// Latvia + internal static let latvia = L10n.tr("Localizable", "enum.browsing_country.name.latvia", fallback: "Latvia") + /// Lebanon + internal static let lebanon = L10n.tr("Localizable", "enum.browsing_country.name.lebanon", fallback: "Lebanon") + /// Lesotho + internal static let lesotho = L10n.tr("Localizable", "enum.browsing_country.name.lesotho", fallback: "Lesotho") + /// Liberia + internal static let liberia = L10n.tr("Localizable", "enum.browsing_country.name.liberia", fallback: "Liberia") + /// Libya + internal static let libya = L10n.tr("Localizable", "enum.browsing_country.name.libya", fallback: "Libya") + /// Liechtenstein + internal static let liechtenstein = L10n.tr("Localizable", "enum.browsing_country.name.liechtenstein", fallback: "Liechtenstein") + /// Lithuania + internal static let lithuania = L10n.tr("Localizable", "enum.browsing_country.name.lithuania", fallback: "Lithuania") + /// Luxembourg + internal static let luxembourg = L10n.tr("Localizable", "enum.browsing_country.name.luxembourg", fallback: "Luxembourg") + /// Macau + internal static let macau = L10n.tr("Localizable", "enum.browsing_country.name.macau", fallback: "Macau") + /// Macedonia + internal static let macedonia = L10n.tr("Localizable", "enum.browsing_country.name.macedonia", fallback: "Macedonia") + /// Madagascar + internal static let madagascar = L10n.tr("Localizable", "enum.browsing_country.name.madagascar", fallback: "Madagascar") + /// Malawi + internal static let malawi = L10n.tr("Localizable", "enum.browsing_country.name.malawi", fallback: "Malawi") + /// Malaysia + internal static let malaysia = L10n.tr("Localizable", "enum.browsing_country.name.malaysia", fallback: "Malaysia") + /// Maldives + internal static let maldives = L10n.tr("Localizable", "enum.browsing_country.name.maldives", fallback: "Maldives") + /// Mali + internal static let mali = L10n.tr("Localizable", "enum.browsing_country.name.mali", fallback: "Mali") + /// Malta + internal static let malta = L10n.tr("Localizable", "enum.browsing_country.name.malta", fallback: "Malta") + /// Marshall Islands + internal static let marshallIslands = L10n.tr("Localizable", "enum.browsing_country.name.marshall_islands", fallback: "Marshall Islands") + /// Martinique + internal static let martinique = L10n.tr("Localizable", "enum.browsing_country.name.martinique", fallback: "Martinique") + /// Mauritania + internal static let mauritania = L10n.tr("Localizable", "enum.browsing_country.name.mauritania", fallback: "Mauritania") + /// Mauritius + internal static let mauritius = L10n.tr("Localizable", "enum.browsing_country.name.mauritius", fallback: "Mauritius") + /// Mayotte + internal static let mayotte = L10n.tr("Localizable", "enum.browsing_country.name.mayotte", fallback: "Mayotte") + /// Mexico + internal static let mexico = L10n.tr("Localizable", "enum.browsing_country.name.mexico", fallback: "Mexico") + /// Micronesia + internal static let micronesia = L10n.tr("Localizable", "enum.browsing_country.name.micronesia", fallback: "Micronesia") + /// Moldova + internal static let moldova = L10n.tr("Localizable", "enum.browsing_country.name.moldova", fallback: "Moldova") + /// Monaco + internal static let monaco = L10n.tr("Localizable", "enum.browsing_country.name.monaco", fallback: "Monaco") + /// Mongolia + internal static let mongolia = L10n.tr("Localizable", "enum.browsing_country.name.mongolia", fallback: "Mongolia") + /// Montenegro + internal static let montenegro = L10n.tr("Localizable", "enum.browsing_country.name.montenegro", fallback: "Montenegro") + /// Montserrat + internal static let montserrat = L10n.tr("Localizable", "enum.browsing_country.name.montserrat", fallback: "Montserrat") + /// Morocco + internal static let morocco = L10n.tr("Localizable", "enum.browsing_country.name.morocco", fallback: "Morocco") + /// Mozambique + internal static let mozambique = L10n.tr("Localizable", "enum.browsing_country.name.mozambique", fallback: "Mozambique") + /// Myanmar + internal static let myanmar = L10n.tr("Localizable", "enum.browsing_country.name.myanmar", fallback: "Myanmar") + /// Namibia + internal static let namibia = L10n.tr("Localizable", "enum.browsing_country.name.namibia", fallback: "Namibia") + /// Nauru + internal static let nauru = L10n.tr("Localizable", "enum.browsing_country.name.nauru", fallback: "Nauru") + /// Nepal + internal static let nepal = L10n.tr("Localizable", "enum.browsing_country.name.nepal", fallback: "Nepal") + /// Netherlands + internal static let netherlands = L10n.tr("Localizable", "enum.browsing_country.name.netherlands", fallback: "Netherlands") + /// New Caledonia + internal static let newCaledonia = L10n.tr("Localizable", "enum.browsing_country.name.new_caledonia", fallback: "New Caledonia") + /// New Zealand + internal static let newZealand = L10n.tr("Localizable", "enum.browsing_country.name.new_zealand", fallback: "New Zealand") + /// Nicaragua + internal static let nicaragua = L10n.tr("Localizable", "enum.browsing_country.name.nicaragua", fallback: "Nicaragua") + /// Niger + internal static let niger = L10n.tr("Localizable", "enum.browsing_country.name.niger", fallback: "Niger") + /// Nigeria + internal static let nigeria = L10n.tr("Localizable", "enum.browsing_country.name.nigeria", fallback: "Nigeria") + /// Niue + internal static let niue = L10n.tr("Localizable", "enum.browsing_country.name.niue", fallback: "Niue") + /// Norfolk Island + internal static let norfolkIsland = L10n.tr("Localizable", "enum.browsing_country.name.norfolk_island", fallback: "Norfolk Island") + /// North Korea + internal static let northKorea = L10n.tr("Localizable", "enum.browsing_country.name.north_korea", fallback: "North Korea") + /// Northern Mariana Islands + internal static let northernMarianaIslands = L10n.tr("Localizable", "enum.browsing_country.name.northern_mariana_islands", fallback: "Northern Mariana Islands") + /// Norway + internal static let norway = L10n.tr("Localizable", "enum.browsing_country.name.norway", fallback: "Norway") + /// Oman + internal static let oman = L10n.tr("Localizable", "enum.browsing_country.name.oman", fallback: "Oman") + /// Pakistan + internal static let pakistan = L10n.tr("Localizable", "enum.browsing_country.name.pakistan", fallback: "Pakistan") + /// Palau + internal static let palau = L10n.tr("Localizable", "enum.browsing_country.name.palau", fallback: "Palau") + /// Palestinian Territory + internal static let palestinianTerritory = L10n.tr("Localizable", "enum.browsing_country.name.palestinian_territory", fallback: "Palestinian Territory") + /// Panama + internal static let panama = L10n.tr("Localizable", "enum.browsing_country.name.panama", fallback: "Panama") + /// Papua New Guinea + internal static let papuaNewGuinea = L10n.tr("Localizable", "enum.browsing_country.name.papua_new_guinea", fallback: "Papua New Guinea") + /// Paraguay + internal static let paraguay = L10n.tr("Localizable", "enum.browsing_country.name.paraguay", fallback: "Paraguay") + /// Peru + internal static let peru = L10n.tr("Localizable", "enum.browsing_country.name.peru", fallback: "Peru") + /// Philippines + internal static let philippines = L10n.tr("Localizable", "enum.browsing_country.name.philippines", fallback: "Philippines") + /// Pitcairn Islands + internal static let pitcairnIslands = L10n.tr("Localizable", "enum.browsing_country.name.pitcairn_islands", fallback: "Pitcairn Islands") + /// Poland + internal static let poland = L10n.tr("Localizable", "enum.browsing_country.name.poland", fallback: "Poland") + /// Portugal + internal static let portugal = L10n.tr("Localizable", "enum.browsing_country.name.portugal", fallback: "Portugal") + /// Puerto Rico + internal static let puertoRico = L10n.tr("Localizable", "enum.browsing_country.name.puerto_rico", fallback: "Puerto Rico") + /// Qatar + internal static let qatar = L10n.tr("Localizable", "enum.browsing_country.name.qatar", fallback: "Qatar") + /// Reunion + internal static let reunion = L10n.tr("Localizable", "enum.browsing_country.name.reunion", fallback: "Reunion") + /// Romania + internal static let romania = L10n.tr("Localizable", "enum.browsing_country.name.romania", fallback: "Romania") + /// Russian Federation + internal static let russianFederation = L10n.tr("Localizable", "enum.browsing_country.name.russian_federation", fallback: "Russian Federation") + /// Rwanda + internal static let rwanda = L10n.tr("Localizable", "enum.browsing_country.name.rwanda", fallback: "Rwanda") + /// Saint Barthelemy + internal static let saintBarthelemy = L10n.tr("Localizable", "enum.browsing_country.name.saint_barthelemy", fallback: "Saint Barthelemy") + /// Saint Helena + internal static let saintHelena = L10n.tr("Localizable", "enum.browsing_country.name.saint_helena", fallback: "Saint Helena") + /// Saint Kitts and Nevis + internal static let saintKittsAndNevis = L10n.tr("Localizable", "enum.browsing_country.name.saint_kitts_and_nevis", fallback: "Saint Kitts and Nevis") + /// Saint Lucia + internal static let saintLucia = L10n.tr("Localizable", "enum.browsing_country.name.saint_lucia", fallback: "Saint Lucia") + /// Saint Martin + internal static let saintMartin = L10n.tr("Localizable", "enum.browsing_country.name.saint_martin", fallback: "Saint Martin") + /// Saint Pierre and Miquelon + internal static let saintPierreAndMiquelon = L10n.tr("Localizable", "enum.browsing_country.name.saint_pierre_and_miquelon", fallback: "Saint Pierre and Miquelon") + /// Saint Vincent and the Grenadines + internal static let saintVincentAndTheGrenadines = L10n.tr("Localizable", "enum.browsing_country.name.saint_vincent_and_the_grenadines", fallback: "Saint Vincent and the Grenadines") + /// Samoa + internal static let samoa = L10n.tr("Localizable", "enum.browsing_country.name.samoa", fallback: "Samoa") + /// San Marino + internal static let sanMarino = L10n.tr("Localizable", "enum.browsing_country.name.san_marino", fallback: "San Marino") + /// Sao Tome and Principe + internal static let saoTomeAndPrincipe = L10n.tr("Localizable", "enum.browsing_country.name.sao_tome_and_principe", fallback: "Sao Tome and Principe") + /// Saudi Arabia + internal static let saudiArabia = L10n.tr("Localizable", "enum.browsing_country.name.saudi_arabia", fallback: "Saudi Arabia") + /// Senegal + internal static let senegal = L10n.tr("Localizable", "enum.browsing_country.name.senegal", fallback: "Senegal") + /// Serbia + internal static let serbia = L10n.tr("Localizable", "enum.browsing_country.name.serbia", fallback: "Serbia") + /// Seychelles + internal static let seychelles = L10n.tr("Localizable", "enum.browsing_country.name.seychelles", fallback: "Seychelles") + /// Sierra Leone + internal static let sierraLeone = L10n.tr("Localizable", "enum.browsing_country.name.sierra_leone", fallback: "Sierra Leone") + /// Singapore + internal static let singapore = L10n.tr("Localizable", "enum.browsing_country.name.singapore", fallback: "Singapore") + /// Sint Maarten + internal static let sintMaarten = L10n.tr("Localizable", "enum.browsing_country.name.sint_maarten", fallback: "Sint Maarten") + /// Slovakia + internal static let slovakia = L10n.tr("Localizable", "enum.browsing_country.name.slovakia", fallback: "Slovakia") + /// Slovenia + internal static let slovenia = L10n.tr("Localizable", "enum.browsing_country.name.slovenia", fallback: "Slovenia") + /// Solomon Islands + internal static let solomonIslands = L10n.tr("Localizable", "enum.browsing_country.name.solomon_islands", fallback: "Solomon Islands") + /// Somalia + internal static let somalia = L10n.tr("Localizable", "enum.browsing_country.name.somalia", fallback: "Somalia") + /// South Africa + internal static let southAfrica = L10n.tr("Localizable", "enum.browsing_country.name.south_africa", fallback: "South Africa") + /// South Georgia and the South Sandwich Islands + internal static let southGeorgiaAndTheSouthSandwichIslands = L10n.tr("Localizable", "enum.browsing_country.name.south_georgia_and_the_south_sandwich_islands", fallback: "South Georgia and the South Sandwich Islands") + /// South Korea + internal static let southKorea = L10n.tr("Localizable", "enum.browsing_country.name.south_korea", fallback: "South Korea") + /// South Sudan + internal static let southSudan = L10n.tr("Localizable", "enum.browsing_country.name.south_sudan", fallback: "South Sudan") + /// Spain + internal static let spain = L10n.tr("Localizable", "enum.browsing_country.name.spain", fallback: "Spain") + /// Sri Lanka + internal static let sriLanka = L10n.tr("Localizable", "enum.browsing_country.name.sri_lanka", fallback: "Sri Lanka") + /// Sudan + internal static let sudan = L10n.tr("Localizable", "enum.browsing_country.name.sudan", fallback: "Sudan") + /// Suriname + internal static let suriname = L10n.tr("Localizable", "enum.browsing_country.name.suriname", fallback: "Suriname") + /// Svalbard and Jan Mayen + internal static let svalbardAndJanMayen = L10n.tr("Localizable", "enum.browsing_country.name.svalbard_and_jan_mayen", fallback: "Svalbard and Jan Mayen") + /// Swaziland + internal static let swaziland = L10n.tr("Localizable", "enum.browsing_country.name.swaziland", fallback: "Swaziland") + /// Sweden + internal static let sweden = L10n.tr("Localizable", "enum.browsing_country.name.sweden", fallback: "Sweden") + /// Switzerland + internal static let switzerland = L10n.tr("Localizable", "enum.browsing_country.name.switzerland", fallback: "Switzerland") + /// Syrian Arab Republic + internal static let syrianArabRepublic = L10n.tr("Localizable", "enum.browsing_country.name.syrian_arab_republic", fallback: "Syrian Arab Republic") + /// Taiwan + internal static let taiwan = L10n.tr("Localizable", "enum.browsing_country.name.taiwan", fallback: "Taiwan") + /// Tajikistan + internal static let tajikistan = L10n.tr("Localizable", "enum.browsing_country.name.tajikistan", fallback: "Tajikistan") + /// Tanzania + internal static let tanzania = L10n.tr("Localizable", "enum.browsing_country.name.tanzania", fallback: "Tanzania") + /// Thailand + internal static let thailand = L10n.tr("Localizable", "enum.browsing_country.name.thailand", fallback: "Thailand") + /// The Democratic Republic of the Congo + internal static let theDemocraticRepublicOfTheCongo = L10n.tr("Localizable", "enum.browsing_country.name.the_democratic_republic_of_the_congo", fallback: "The Democratic Republic of the Congo") + /// Timor-Leste + internal static let timorLeste = L10n.tr("Localizable", "enum.browsing_country.name.timor_leste", fallback: "Timor-Leste") + /// Togo + internal static let togo = L10n.tr("Localizable", "enum.browsing_country.name.togo", fallback: "Togo") + /// Tokelau + internal static let tokelau = L10n.tr("Localizable", "enum.browsing_country.name.tokelau", fallback: "Tokelau") + /// Tonga + internal static let tonga = L10n.tr("Localizable", "enum.browsing_country.name.tonga", fallback: "Tonga") + /// Trinidad and Tobago + internal static let trinidadAndTobago = L10n.tr("Localizable", "enum.browsing_country.name.trinidad_and_tobago", fallback: "Trinidad and Tobago") + /// Tunisia + internal static let tunisia = L10n.tr("Localizable", "enum.browsing_country.name.tunisia", fallback: "Tunisia") + /// Turkey + internal static let turkey = L10n.tr("Localizable", "enum.browsing_country.name.turkey", fallback: "Turkey") + /// Turkmenistan + internal static let turkmenistan = L10n.tr("Localizable", "enum.browsing_country.name.turkmenistan", fallback: "Turkmenistan") + /// Turks and Caicos Islands + internal static let turksAndCaicosIslands = L10n.tr("Localizable", "enum.browsing_country.name.turks_and_caicos_islands", fallback: "Turks and Caicos Islands") + /// Tuvalu + internal static let tuvalu = L10n.tr("Localizable", "enum.browsing_country.name.tuvalu", fallback: "Tuvalu") + /// Uganda + internal static let uganda = L10n.tr("Localizable", "enum.browsing_country.name.uganda", fallback: "Uganda") + /// Ukraine + internal static let ukraine = L10n.tr("Localizable", "enum.browsing_country.name.ukraine", fallback: "Ukraine") + /// United Arab Emirates + internal static let unitedArabEmirates = L10n.tr("Localizable", "enum.browsing_country.name.united_arab_emirates", fallback: "United Arab Emirates") + /// United Kingdom + internal static let unitedKingdom = L10n.tr("Localizable", "enum.browsing_country.name.united_kingdom", fallback: "United Kingdom") + /// United States + internal static let unitedStates = L10n.tr("Localizable", "enum.browsing_country.name.united_states", fallback: "United States") + /// United States Minor Outlying Islands + internal static let unitedStatesMinorOutlyingIslands = L10n.tr("Localizable", "enum.browsing_country.name.united_states_minor_outlying_islands", fallback: "United States Minor Outlying Islands") + /// Uruguay + internal static let uruguay = L10n.tr("Localizable", "enum.browsing_country.name.uruguay", fallback: "Uruguay") + /// Uzbekistan + internal static let uzbekistan = L10n.tr("Localizable", "enum.browsing_country.name.uzbekistan", fallback: "Uzbekistan") + /// Vanuatu + internal static let vanuatu = L10n.tr("Localizable", "enum.browsing_country.name.vanuatu", fallback: "Vanuatu") + /// Vatican City State + internal static let vaticanCityState = L10n.tr("Localizable", "enum.browsing_country.name.vatican_city_state", fallback: "Vatican City State") + /// Venezuela + internal static let venezuela = L10n.tr("Localizable", "enum.browsing_country.name.venezuela", fallback: "Venezuela") + /// Vietnam + internal static let vietnam = L10n.tr("Localizable", "enum.browsing_country.name.vietnam", fallback: "Vietnam") + /// British Virgin Islands + internal static let virginIslandsBritish = L10n.tr("Localizable", "enum.browsing_country.name.virgin_islands_british", fallback: "British Virgin Islands") + /// U.S. Virgin Islands + internal static let virginIslandsUS = L10n.tr("Localizable", "enum.browsing_country.name.virgin_islands_US", fallback: "U.S. Virgin Islands") + /// Wallis and Futuna + internal static let wallisAndFutuna = L10n.tr("Localizable", "enum.browsing_country.name.wallis_and_futuna", fallback: "Wallis and Futuna") + /// Western Sahara + internal static let westernSahara = L10n.tr("Localizable", "enum.browsing_country.name.western_sahara", fallback: "Western Sahara") + /// Yemen + internal static let yemen = L10n.tr("Localizable", "enum.browsing_country.name.yemen", fallback: "Yemen") + /// Zambia + internal static let zambia = L10n.tr("Localizable", "enum.browsing_country.name.zambia", fallback: "Zambia") + /// Zimbabwe + internal static let zimbabwe = L10n.tr("Localizable", "enum.browsing_country.name.zimbabwe", fallback: "Zimbabwe") + } + } + internal enum Category { + internal enum Value { + /// Artist CG + internal static let artistCG = L10n.tr("Localizable", "enum.category.value.artist_CG", fallback: "Artist CG") + /// Asian Porn + internal static let asianPorn = L10n.tr("Localizable", "enum.category.value.asian_porn", fallback: "Asian Porn") + /// Cosplay + internal static let cosplay = L10n.tr("Localizable", "enum.category.value.cosplay", fallback: "Cosplay") + /// Doujinshi + internal static let doujinshi = L10n.tr("Localizable", "enum.category.value.doujinshi", fallback: "Doujinshi") + /// Game CG + internal static let gameCG = L10n.tr("Localizable", "enum.category.value.game_CG", fallback: "Game CG") + /// Image Set + internal static let imageSet = L10n.tr("Localizable", "enum.category.value.image_set", fallback: "Image Set") + /// Manga + internal static let manga = L10n.tr("Localizable", "enum.category.value.manga", fallback: "Manga") + /// Misc + internal static let misc = L10n.tr("Localizable", "enum.category.value.misc", fallback: "Misc") + /// Non-H + internal static let nonH = L10n.tr("Localizable", "enum.category.value.non_h", fallback: "Non-H") + /// Private + internal static let `private` = L10n.tr("Localizable", "enum.category.value.private", fallback: "Private") + /// Western + internal static let western = L10n.tr("Localizable", "enum.category.value.western", fallback: "Western") + } + } + internal enum EhSetting { + internal enum ArchiverBehavior { + internal enum Value { + /// Auto Select Original, Auto Start + internal static let autoSelectOriginalAutoStart = L10n.tr("Localizable", "enum.eh_setting.archiver_behavior.value.auto_select_original_auto_start", fallback: "Auto Select Original, Auto Start") + /// Auto Select Original, Manual Start + internal static let autoSelectOriginalManualStart = L10n.tr("Localizable", "enum.eh_setting.archiver_behavior.value.auto_select_original_manual_start", fallback: "Auto Select Original, Manual Start") + /// Auto Select Resample, Auto Start + internal static let autoSelectResampleAutoStart = L10n.tr("Localizable", "enum.eh_setting.archiver_behavior.value.auto_select_resample_auto_start", fallback: "Auto Select Resample, Auto Start") + /// Auto Select Resample, Manual Start + internal static let autoSelectResampleManualStart = L10n.tr("Localizable", "enum.eh_setting.archiver_behavior.value.auto_select_resample_manual_start", fallback: "Auto Select Resample, Manual Start") + /// Manual Select, Auto Start + internal static let manualSelectAutoStart = L10n.tr("Localizable", "enum.eh_setting.archiver_behavior.value.manual_select_auto_start", fallback: "Manual Select, Auto Start") + /// Manual Select, Manual Start (Default) + internal static let manualSelectManualStart = L10n.tr("Localizable", "enum.eh_setting.archiver_behavior.value.manual_select_manual_start", fallback: "Manual Select, Manual Start (Default)") + } + } + internal enum CommentsSortOrder { + internal enum Value { + /// By highest score + internal static let highestScore = L10n.tr("Localizable", "enum.eh_setting.comments_sort_order.value.highest_score", fallback: "By highest score") + /// Oldest comments first + internal static let oldest = L10n.tr("Localizable", "enum.eh_setting.comments_sort_order.value.oldest", fallback: "Oldest comments first") + /// Recent comments first + internal static let recent = L10n.tr("Localizable", "enum.eh_setting.comments_sort_order.value.recent", fallback: "Recent comments first") + } + } + internal enum CommentsVotesShowTiming { + internal enum Value { + /// Always + internal static let always = L10n.tr("Localizable", "enum.eh_setting.comments_votes_show_timing.value.always", fallback: "Always") + /// On score hover or click + internal static let onHoverOrClick = L10n.tr("Localizable", "enum.eh_setting.comments_votes_show_timing.value.on_hover_or_click", fallback: "On score hover or click") + } + } + internal enum DisplayMode { + internal enum Value { + /// Compact + internal static let compact = L10n.tr("Localizable", "enum.eh_setting.display_mode.value.compact", fallback: "Compact") + /// Extended + internal static let extended = L10n.tr("Localizable", "enum.eh_setting.display_mode.value.extended", fallback: "Extended") + /// Minimal + internal static let minimal = L10n.tr("Localizable", "enum.eh_setting.display_mode.value.minimal", fallback: "Minimal") + /// Minimal+ + internal static let minimalPlus = L10n.tr("Localizable", "enum.eh_setting.display_mode.value.minimalPlus", fallback: "Minimal+") + /// Thumbnail + internal static let thumbnail = L10n.tr("Localizable", "enum.eh_setting.display_mode.value.thumbnail", fallback: "Thumbnail") + } + } + internal enum ExcludedLanguagesCategory { + internal enum Value { + /// Original + internal static let original = L10n.tr("Localizable", "enum.eh_setting.excluded_languages_category.value.original", fallback: "Original") + /// Rewrite + internal static let rewrite = L10n.tr("Localizable", "enum.eh_setting.excluded_languages_category.value.rewrite", fallback: "Rewrite") + /// Translated + internal static let translated = L10n.tr("Localizable", "enum.eh_setting.excluded_languages_category.value.translated", fallback: "Translated") + } + } + internal enum FavoritesSortOrder { + internal enum Value { + /// By favorited time + internal static let favoritedTime = L10n.tr("Localizable", "enum.eh_setting.favorites_sort_order.value.favorited_time", fallback: "By favorited time") + /// By last gallery update time + internal static let lastUpdateTime = L10n.tr("Localizable", "enum.eh_setting.favorites_sort_order.value.last_update_time", fallback: "By last gallery update time") + } + } + internal enum GalleryName { + internal enum Value { + /// Default Title + internal static let `default` = L10n.tr("Localizable", "enum.eh_setting.gallery_name.value.default", fallback: "Default Title") + /// Japanese Title (if available) + internal static let japanese = L10n.tr("Localizable", "enum.eh_setting.gallery_name.value.japanese", fallback: "Japanese Title (if available)") + } + } + internal enum ImageResolution { + internal enum Value { + /// Auto + internal static let auto = L10n.tr("Localizable", "enum.eh_setting.image_resolution.value.auto", fallback: "Auto") + } + } + internal enum LoadThroughHathSetting { + internal enum Description { + /// Recommended. + internal static let anyClient = L10n.tr("Localizable", "enum.eh_setting.load_through_hath_setting.description.any_client", fallback: "Recommended.") + /// Can be slower. Enable if behind firewall/proxy that blocks outgoing non-standard ports. + internal static let defaultPortOnly = L10n.tr("Localizable", "enum.eh_setting.load_through_hath_setting.description.default_port_only", fallback: "Can be slower. Enable if behind firewall/proxy that blocks outgoing non-standard ports.") + /// Donator only. May not work by default in modern browsers. Recommended for legacy/outdated browsers only. + internal static let legacyNo = L10n.tr("Localizable", "enum.eh_setting.load_through_hath_setting.description.legacy_no", fallback: "Donator only. May not work by default in modern browsers. Recommended for legacy/outdated browsers only.") + /// Donator only. You will not be able to browse as many pages. Recommended only if having severe problems. + internal static let modernNo = L10n.tr("Localizable", "enum.eh_setting.load_through_hath_setting.description.modern_no", fallback: "Donator only. You will not be able to browse as many pages. Recommended only if having severe problems.") + } + internal enum Value { + /// Any client + internal static let anyClient = L10n.tr("Localizable", "enum.eh_setting.load_through_hath_setting.value.any_client", fallback: "Any client") + /// Default port clients only + internal static let defaultPortOnly = L10n.tr("Localizable", "enum.eh_setting.load_through_hath_setting.value.default_port_only", fallback: "Default port clients only") + /// No [Legacy/HTTP] + internal static let legacyNo = L10n.tr("Localizable", "enum.eh_setting.load_through_hath_setting.value.legacy_no", fallback: "No [Legacy/HTTP]") + /// No [Modern/HTTPS] + internal static let modernNo = L10n.tr("Localizable", "enum.eh_setting.load_through_hath_setting.value.modern_no", fallback: "No [Modern/HTTPS]") + } + } + internal enum MultiplePageViewerStyle { + internal enum Value { + /// Align center, always scale + internal static let alignCenterAlwaysScale = L10n.tr("Localizable", "enum.eh_setting.multiple_page_viewer_style.value.align_center_always_scale", fallback: "Align center, always scale") + /// Align center, scale if overwidth + internal static let alignCenterScaleIfOverWidth = L10n.tr("Localizable", "enum.eh_setting.multiple_page_viewer_style.value.align_center_scale_if_over_width", fallback: "Align center, scale if overwidth") + /// Align left, scale if overwidth + internal static let alignLeftScaleIfOverWidth = L10n.tr("Localizable", "enum.eh_setting.multiple_page_viewer_style.value.align_left_scale_if_over_width", fallback: "Align left, scale if overwidth") + } + } + internal enum TagsSortOrder { + internal enum Value { + /// Alphabetical + internal static let alphabetical = L10n.tr("Localizable", "enum.eh_setting.tags_sort_order.value.alphabetical", fallback: "Alphabetical") + /// By tag power + internal static let tagPower = L10n.tr("Localizable", "enum.eh_setting.tags_sort_order.value.tag_power", fallback: "By tag power") + } + } + internal enum ThumbnailLoadTiming { + internal enum Description { + /// Pages load faster, but there may be a slight delay before a thumb appears. + internal static let onMouseOver = L10n.tr("Localizable", "enum.eh_setting.thumbnail_load_timing.description.on_mouse_over", fallback: "Pages load faster, but there may be a slight delay before a thumb appears.") + /// Pages take longer to load, but there is no delay for loading a thumb after the page has loaded. + internal static let onPageLoad = L10n.tr("Localizable", "enum.eh_setting.thumbnail_load_timing.description.on_page_load", fallback: "Pages take longer to load, but there is no delay for loading a thumb after the page has loaded.") + } + internal enum Value { + /// On mouse-over + internal static let onMouseOver = L10n.tr("Localizable", "enum.eh_setting.thumbnail_load_timing.value.on_mouse_over", fallback: "On mouse-over") + /// On page load + internal static let onPageLoad = L10n.tr("Localizable", "enum.eh_setting.thumbnail_load_timing.value.on_page_load", fallback: "On page load") + } + } + internal enum ThumbnailSize { + internal enum Value { + /// Large + internal static let large = L10n.tr("Localizable", "enum.eh_setting.thumbnail_size.value.large", fallback: "Large") + /// Normal + internal static let normal = L10n.tr("Localizable", "enum.eh_setting.thumbnail_size.value.normal", fallback: "Normal") + } + } + } + internal enum FilterRange { + internal enum Value { + /// Global + internal static let global = L10n.tr("Localizable", "enum.filter_range.value.global", fallback: "Global") + /// Search + internal static let search = L10n.tr("Localizable", "enum.filter_range.value.search", fallback: "Search") + /// Watched + internal static let watched = L10n.tr("Localizable", "enum.filter_range.value.watched", fallback: "Watched") + } + } + internal enum GalleryVisibility { + internal enum Value { + /// No (%@) + internal static func no(_ p1: Any) -> String { + return L10n.tr("Localizable", "enum.gallery_visibility.value.no", String(describing: p1), fallback: "No (%@)") + } + /// Yes + internal static let yes = L10n.tr("Localizable", "enum.gallery_visibility.value.yes", fallback: "Yes") + internal enum No { + internal enum Reason { + /// Expunged + internal static let expunged = L10n.tr("Localizable", "enum.gallery_visibility.value.no.reason.expunged", fallback: "Expunged") + } + } + } + } + internal enum HomeMiscGridType { + internal enum Title { + /// History + internal static let history = L10n.tr("Localizable", "enum.home_misc_grid_type.title.history", fallback: "History") + /// Popular + internal static let popular = L10n.tr("Localizable", "enum.home_misc_grid_type.title.popular", fallback: "Popular") + /// Watched + internal static let watched = L10n.tr("Localizable", "enum.home_misc_grid_type.title.watched", fallback: "Watched") + } + } + internal enum Language { + internal enum Value { + /// Afrikaans + internal static let afrikaans = L10n.tr("Localizable", "enum.language.value.afrikaans", fallback: "Afrikaans") + /// Albanian + internal static let albanian = L10n.tr("Localizable", "enum.language.value.albanian", fallback: "Albanian") + /// Arabic + internal static let arabic = L10n.tr("Localizable", "enum.language.value.arabic", fallback: "Arabic") + /// Bengali + internal static let bengali = L10n.tr("Localizable", "enum.language.value.bengali", fallback: "Bengali") + /// Bosnian + internal static let bosnian = L10n.tr("Localizable", "enum.language.value.bosnian", fallback: "Bosnian") + /// Bulgarian + internal static let bulgarian = L10n.tr("Localizable", "enum.language.value.bulgarian", fallback: "Bulgarian") + /// Burmese + internal static let burmese = L10n.tr("Localizable", "enum.language.value.burmese", fallback: "Burmese") + /// Catalan + internal static let catalan = L10n.tr("Localizable", "enum.language.value.catalan", fallback: "Catalan") + /// Cebuano + internal static let cebuano = L10n.tr("Localizable", "enum.language.value.cebuano", fallback: "Cebuano") + /// Chinese + internal static let chinese = L10n.tr("Localizable", "enum.language.value.chinese", fallback: "Chinese") + /// Croatian + internal static let croatian = L10n.tr("Localizable", "enum.language.value.croatian", fallback: "Croatian") + /// Czech + internal static let czech = L10n.tr("Localizable", "enum.language.value.czech", fallback: "Czech") + /// Danish + internal static let danish = L10n.tr("Localizable", "enum.language.value.danish", fallback: "Danish") + /// Dutch + internal static let dutch = L10n.tr("Localizable", "enum.language.value.dutch", fallback: "Dutch") + /// English + internal static let english = L10n.tr("Localizable", "enum.language.value.english", fallback: "English") + /// Esperanto + internal static let esperanto = L10n.tr("Localizable", "enum.language.value.esperanto", fallback: "Esperanto") + /// Estonian + internal static let estonian = L10n.tr("Localizable", "enum.language.value.estonian", fallback: "Estonian") + /// Finnish + internal static let finnish = L10n.tr("Localizable", "enum.language.value.finnish", fallback: "Finnish") + /// French + internal static let french = L10n.tr("Localizable", "enum.language.value.french", fallback: "French") + /// Georgian + internal static let georgian = L10n.tr("Localizable", "enum.language.value.georgian", fallback: "Georgian") + /// German + internal static let german = L10n.tr("Localizable", "enum.language.value.german", fallback: "German") + /// Greek + internal static let greek = L10n.tr("Localizable", "enum.language.value.greek", fallback: "Greek") + /// Hebrew + internal static let hebrew = L10n.tr("Localizable", "enum.language.value.hebrew", fallback: "Hebrew") + /// Hindi + internal static let hindi = L10n.tr("Localizable", "enum.language.value.hindi", fallback: "Hindi") + /// Hmong + internal static let hmong = L10n.tr("Localizable", "enum.language.value.hmong", fallback: "Hmong") + /// Hungarian + internal static let hungarian = L10n.tr("Localizable", "enum.language.value.hungarian", fallback: "Hungarian") + /// Indonesian + internal static let indonesian = L10n.tr("Localizable", "enum.language.value.indonesian", fallback: "Indonesian") + /// N/A + internal static let invalid = L10n.tr("Localizable", "enum.language.value.invalid", fallback: "N/A") + /// Italian + internal static let italian = L10n.tr("Localizable", "enum.language.value.italian", fallback: "Italian") + /// Japanese + internal static let japanese = L10n.tr("Localizable", "enum.language.value.japanese", fallback: "Japanese") + /// Kazakh + internal static let kazakh = L10n.tr("Localizable", "enum.language.value.kazakh", fallback: "Kazakh") + /// Khmer + internal static let khmer = L10n.tr("Localizable", "enum.language.value.khmer", fallback: "Khmer") + /// Korean + internal static let korean = L10n.tr("Localizable", "enum.language.value.korean", fallback: "Korean") + /// Kurdish + internal static let kurdish = L10n.tr("Localizable", "enum.language.value.kurdish", fallback: "Kurdish") + /// Lao + internal static let lao = L10n.tr("Localizable", "enum.language.value.lao", fallback: "Lao") + /// Latin + internal static let latin = L10n.tr("Localizable", "enum.language.value.latin", fallback: "Latin") + /// Mongolian + internal static let mongolian = L10n.tr("Localizable", "enum.language.value.mongolian", fallback: "Mongolian") + /// Ndebele + internal static let ndebele = L10n.tr("Localizable", "enum.language.value.ndebele", fallback: "Ndebele") + /// Nepali + internal static let nepali = L10n.tr("Localizable", "enum.language.value.nepali", fallback: "Nepali") + /// Norwegian + internal static let norwegian = L10n.tr("Localizable", "enum.language.value.norwegian", fallback: "Norwegian") + /// Oromo + internal static let oromo = L10n.tr("Localizable", "enum.language.value.oromo", fallback: "Oromo") + /// Other + internal static let other = L10n.tr("Localizable", "enum.language.value.other", fallback: "Other") + /// Pashto + internal static let pashto = L10n.tr("Localizable", "enum.language.value.pashto", fallback: "Pashto") + /// Persian + internal static let persian = L10n.tr("Localizable", "enum.language.value.persian", fallback: "Persian") + /// Polish + internal static let polish = L10n.tr("Localizable", "enum.language.value.polish", fallback: "Polish") + /// Portuguese + internal static let portuguese = L10n.tr("Localizable", "enum.language.value.portuguese", fallback: "Portuguese") + /// Punjabi + internal static let punjabi = L10n.tr("Localizable", "enum.language.value.punjabi", fallback: "Punjabi") + /// Romanian + internal static let romanian = L10n.tr("Localizable", "enum.language.value.romanian", fallback: "Romanian") + /// Russian + internal static let russian = L10n.tr("Localizable", "enum.language.value.russian", fallback: "Russian") + /// Sango + internal static let sango = L10n.tr("Localizable", "enum.language.value.sango", fallback: "Sango") + /// Serbian + internal static let serbian = L10n.tr("Localizable", "enum.language.value.serbian", fallback: "Serbian") + /// Shona + internal static let shona = L10n.tr("Localizable", "enum.language.value.shona", fallback: "Shona") + /// Slovak + internal static let slovak = L10n.tr("Localizable", "enum.language.value.slovak", fallback: "Slovak") + /// Slovenian + internal static let slovenian = L10n.tr("Localizable", "enum.language.value.slovenian", fallback: "Slovenian") + /// Somali + internal static let somali = L10n.tr("Localizable", "enum.language.value.somali", fallback: "Somali") + /// Spanish + internal static let spanish = L10n.tr("Localizable", "enum.language.value.spanish", fallback: "Spanish") + /// Swahili + internal static let swahili = L10n.tr("Localizable", "enum.language.value.swahili", fallback: "Swahili") + /// Swedish + internal static let swedish = L10n.tr("Localizable", "enum.language.value.swedish", fallback: "Swedish") + /// Tagalog + internal static let tagalog = L10n.tr("Localizable", "enum.language.value.tagalog", fallback: "Tagalog") + /// Thai + internal static let thai = L10n.tr("Localizable", "enum.language.value.thai", fallback: "Thai") + /// Tigrinya + internal static let tigrinya = L10n.tr("Localizable", "enum.language.value.tigrinya", fallback: "Tigrinya") + /// Turkish + internal static let turkish = L10n.tr("Localizable", "enum.language.value.turkish", fallback: "Turkish") + /// Ukrainian + internal static let ukrainian = L10n.tr("Localizable", "enum.language.value.ukrainian", fallback: "Ukrainian") + /// Urdu + internal static let urdu = L10n.tr("Localizable", "enum.language.value.urdu", fallback: "Urdu") + /// Vietnamese + internal static let vietnamese = L10n.tr("Localizable", "enum.language.value.vietnamese", fallback: "Vietnamese") + /// Zulu + internal static let zulu = L10n.tr("Localizable", "enum.language.value.zulu", fallback: "Zulu") + } + } + internal enum ListDisplayMode { + internal enum Value { + /// Detail + internal static let detail = L10n.tr("Localizable", "enum.list_display_mode.value.detail", fallback: "Detail") + /// Thumbnail + internal static let thumbnail = L10n.tr("Localizable", "enum.list_display_mode.value.thumbnail", fallback: "Thumbnail") + } + } + internal enum PreferredColorScheme { + internal enum Value { + /// Automatic + internal static let automatic = L10n.tr("Localizable", "enum.preferred_color_scheme.value.automatic", fallback: "Automatic") + /// Dark + internal static let dark = L10n.tr("Localizable", "enum.preferred_color_scheme.value.dark", fallback: "Dark") + /// Light + internal static let light = L10n.tr("Localizable", "enum.preferred_color_scheme.value.light", fallback: "Light") + } + } + internal enum ReadingDirection { + internal enum Value { + /// Left-to-right + internal static let leftToRight = L10n.tr("Localizable", "enum.reading_direction.value.left_to_right", fallback: "Left-to-right") + /// Right-to-left + internal static let rightToLeft = L10n.tr("Localizable", "enum.reading_direction.value.right_to_left", fallback: "Right-to-left") + /// Vertical + internal static let vertical = L10n.tr("Localizable", "enum.reading_direction.value.vertical", fallback: "Vertical") + } + } + internal enum SettingStateRoute { + internal enum Value { + /// About EhPanda + internal static let about = L10n.tr("Localizable", "enum.setting_state_route.value.about", fallback: "About EhPanda") + /// Account + internal static let account = L10n.tr("Localizable", "enum.setting_state_route.value.account", fallback: "Account") + /// Appearance + internal static let appearance = L10n.tr("Localizable", "enum.setting_state_route.value.appearance", fallback: "Appearance") + /// General + internal static let general = L10n.tr("Localizable", "enum.setting_state_route.value.general", fallback: "General") + /// Laboratory + internal static let laboratory = L10n.tr("Localizable", "enum.setting_state_route.value.laboratory", fallback: "Laboratory") + /// Reading + internal static let reading = L10n.tr("Localizable", "enum.setting_state_route.value.reading", fallback: "Reading") + } + } + internal enum TagNamespace { + internal enum Value { + /// Artist + internal static let artist = L10n.tr("Localizable", "enum.tag_namespace.value.artist", fallback: "Artist") + /// Character + internal static let character = L10n.tr("Localizable", "enum.tag_namespace.value.character", fallback: "Character") + /// Cosplayer + internal static let cosplayer = L10n.tr("Localizable", "enum.tag_namespace.value.cosplayer", fallback: "Cosplayer") + /// Female + internal static let female = L10n.tr("Localizable", "enum.tag_namespace.value.female", fallback: "Female") + /// Group + internal static let group = L10n.tr("Localizable", "enum.tag_namespace.value.group", fallback: "Group") + /// Language + internal static let language = L10n.tr("Localizable", "enum.tag_namespace.value.language", fallback: "Language") + /// Male + internal static let male = L10n.tr("Localizable", "enum.tag_namespace.value.male", fallback: "Male") + /// Mixed + internal static let mixed = L10n.tr("Localizable", "enum.tag_namespace.value.mixed", fallback: "Mixed") + /// Other + internal static let other = L10n.tr("Localizable", "enum.tag_namespace.value.other", fallback: "Other") + /// Parody + internal static let parody = L10n.tr("Localizable", "enum.tag_namespace.value.parody", fallback: "Parody") + /// Reclass + internal static let reclass = L10n.tr("Localizable", "enum.tag_namespace.value.reclass", fallback: "Reclass") + /// Temp + internal static let temp = L10n.tr("Localizable", "enum.tag_namespace.value.temp", fallback: "Temp") + } + } + internal enum ToplistsType { + internal enum Value { + /// All time + internal static let allTime = L10n.tr("Localizable", "enum.toplists_type.value.all_time", fallback: "All time") + /// Past month + internal static let pastMonth = L10n.tr("Localizable", "enum.toplists_type.value.past_month", fallback: "Past month") + /// Past year + internal static let pastYear = L10n.tr("Localizable", "enum.toplists_type.value.past_year", fallback: "Past year") + /// Yesterday + internal static let yesterday = L10n.tr("Localizable", "enum.toplists_type.value.yesterday", fallback: "Yesterday") + } + } + } + internal enum ErrorView { + internal enum Button { + /// Drop the database + internal static let dropDatabase = L10n.tr("Localizable", "error_view.button.drop_database", fallback: "Drop the database") + /// Retry + internal static let retry = L10n.tr("Localizable", "error_view.button.retry", fallback: "Retry") + } + internal enum Title { + /// This gallery is unavailable due to a copyright claim by %@. Sorry about that. + internal static func copyrightClaim(_ p1: Any) -> String { + return L10n.tr("Localizable", "error_view.title.copyright_claim", String(describing: p1), fallback: "This gallery is unavailable due to a copyright claim by %@. Sorry about that.") + } + /// The database is corrupted. + /// Please submit an issue on GitHub. + internal static let databaseCorrupted = L10n.tr("Localizable", "error_view.title.database_corrupted", fallback: "The database is corrupted.\nPlease submit an issue on GitHub.") + /// This gallery has been removed or is unavailable. + internal static let galleryUnavailable = L10n.tr("Localizable", "error_view.title.gallery_unavailable", fallback: "This gallery has been removed or is unavailable.") + /// Your IP address has been temporarily banned for excessive pageloads which indicates that you are using automated mirroring / harvesting software. The ban expires in %@. + internal static func ipBanned(_ p1: Any) -> String { + return L10n.tr("Localizable", "error_view.title.ip_banned", String(describing: p1), fallback: "Your IP address has been temporarily banned for excessive pageloads which indicates that you are using automated mirroring / harvesting software. The ban expires in %@.") + } + /// A network error occurred. + internal static let network = L10n.tr("Localizable", "error_view.title.network", fallback: "A network error occurred.") + /// There seems to be nothing here. + internal static let notFound = L10n.tr("Localizable", "error_view.title.not_found", fallback: "There seems to be nothing here.") + /// A parsing error occurred. + internal static let parsing = L10n.tr("Localizable", "error_view.title.parsing", fallback: "A parsing error occurred.") + /// Please try again later. + internal static let tryLater = L10n.tr("Localizable", "error_view.title.try_later", fallback: "Please try again later.") + /// An unknown error occurred. + internal static let unknown = L10n.tr("Localizable", "error_view.title.unknown", fallback: "An unknown error occurred.") + } + } + internal enum FavoritesView { + internal enum Title { + /// Favorites + internal static let favorites = L10n.tr("Localizable", "favorites_view.title.favorites", fallback: "Favorites") + } + } + internal enum FiltersView { + internal enum Button { + /// Reset filters + internal static let resetFilters = L10n.tr("Localizable", "filters_view.button.reset_filters", fallback: "Reset filters") + } + internal enum Section { + internal enum Title { + /// Advanced + internal static let advanced = L10n.tr("Localizable", "filters_view.section.title.advanced", fallback: "Advanced") + /// Default filter + internal static let defaultFilter = L10n.tr("Localizable", "filters_view.section.title.default_filter", fallback: "Default filter") + } + } + internal enum Title { + /// Advanced settings + internal static let advancedSettings = L10n.tr("Localizable", "filters_view.title.advanced_settings", fallback: "Advanced settings") + /// Disable language filter + internal static let disableLanguageFilter = L10n.tr("Localizable", "filters_view.title.disable_language_filter", fallback: "Disable language filter") + /// Disable tags filter + internal static let disableTagsFilter = L10n.tr("Localizable", "filters_view.title.disable_tags_filter", fallback: "Disable tags filter") + /// Disable uploader filter + internal static let disableUploaderFilter = L10n.tr("Localizable", "filters_view.title.disable_uploader_filter", fallback: "Disable uploader filter") + /// Filters + internal static let filters = L10n.tr("Localizable", "filters_view.title.filters", fallback: "Filters") + /// Minimum rating + internal static let minimumRating = L10n.tr("Localizable", "filters_view.title.minimum_rating", fallback: "Minimum rating") + /// Only show galleries with torrents + internal static let onlyShowGalleriesWithTorrents = L10n.tr("Localizable", "filters_view.title.only_show_galleries_with_torrents", fallback: "Only show galleries with torrents") + /// Pages range + internal static let pagesRange = L10n.tr("Localizable", "filters_view.title.pages_range", fallback: "Pages range") + /// Search downvoted tags + internal static let searchDownvotedTags = L10n.tr("Localizable", "filters_view.title.search_downvoted_tags", fallback: "Search downvoted tags") + /// Search expunged galleries + internal static let searchExpungedGalleries = L10n.tr("Localizable", "filters_view.title.search_expunged_galleries", fallback: "Search expunged galleries") + /// Search gallery description + internal static let searchGalleryDescription = L10n.tr("Localizable", "filters_view.title.search_gallery_description", fallback: "Search gallery description") + /// Search gallery name + internal static let searchGalleryName = L10n.tr("Localizable", "filters_view.title.search_gallery_name", fallback: "Search gallery name") + /// Search gallery tags + internal static let searchGalleryTags = L10n.tr("Localizable", "filters_view.title.search_gallery_tags", fallback: "Search gallery tags") + /// Search Low-Power tags + internal static let searchLowPowerTags = L10n.tr("Localizable", "filters_view.title.search_low_power_tags", fallback: "Search Low-Power tags") + /// Search torrent filenames + internal static let searchTorrentFilenames = L10n.tr("Localizable", "filters_view.title.search_torrent_filenames", fallback: "Search torrent filenames") + /// Set minimum rating + internal static let setMinimumRating = L10n.tr("Localizable", "filters_view.title.set_minimum_rating", fallback: "Set minimum rating") + /// Set pages range + internal static let setPagesRange = L10n.tr("Localizable", "filters_view.title.set_pages_range", fallback: "Set pages range") + } + } + internal enum FrontpageView { + internal enum Title { + /// Frontpage + internal static let frontpage = L10n.tr("Localizable", "frontpage_view.title.frontpage", fallback: "Frontpage") + } + } + internal enum GalleryInfosView { + internal enum Title { + /// Archive URL + internal static let archiveURL = L10n.tr("Localizable", "gallery_infos_view.title.archive_URL", fallback: "Archive URL") + /// Average rating + internal static let averageRating = L10n.tr("Localizable", "gallery_infos_view.title.average_rating", fallback: "Average rating") + /// Category + internal static let category = L10n.tr("Localizable", "gallery_infos_view.title.category", fallback: "Category") + /// Cover URL + internal static let coverURL = L10n.tr("Localizable", "gallery_infos_view.title.cover_URL", fallback: "Cover URL") + /// Favorited + internal static let favorited = L10n.tr("Localizable", "gallery_infos_view.title.favorited", fallback: "Favorited") + /// Favorited times + internal static let favoritedTimes = L10n.tr("Localizable", "gallery_infos_view.title.favorited_times", fallback: "Favorited times") + /// File size + internal static let fileSize = L10n.tr("Localizable", "gallery_infos_view.title.file_size", fallback: "File size") + /// Gallery infos + internal static let galleryInfos = L10n.tr("Localizable", "gallery_infos_view.title.gallery_infos", fallback: "Gallery infos") + /// Gallery URL + internal static let galleryURL = L10n.tr("Localizable", "gallery_infos_view.title.gallery_URL", fallback: "Gallery URL") + /// ID + internal static let id = L10n.tr("Localizable", "gallery_infos_view.title.id", fallback: "ID") + /// Japanese title + internal static let japaneseTitle = L10n.tr("Localizable", "gallery_infos_view.title.japanese_title", fallback: "Japanese title") + /// Language + internal static let language = L10n.tr("Localizable", "gallery_infos_view.title.language", fallback: "Language") + /// My rating + internal static let myRating = L10n.tr("Localizable", "gallery_infos_view.title.my_rating", fallback: "My rating") + /// Page count + internal static let pageCount = L10n.tr("Localizable", "gallery_infos_view.title.page_count", fallback: "Page count") + /// Parent URL + internal static let parentURL = L10n.tr("Localizable", "gallery_infos_view.title.parent_URL", fallback: "Parent URL") + /// Posted date + internal static let postedDate = L10n.tr("Localizable", "gallery_infos_view.title.posted_date", fallback: "Posted date") + /// Rating count + internal static let ratingCount = L10n.tr("Localizable", "gallery_infos_view.title.rating_count", fallback: "Rating count") + /// Title + internal static let title = L10n.tr("Localizable", "gallery_infos_view.title.title", fallback: "Title") + /// Token + internal static let token = L10n.tr("Localizable", "gallery_infos_view.title.token", fallback: "Token") + /// Torrent count + internal static let torrentCount = L10n.tr("Localizable", "gallery_infos_view.title.torrent_count", fallback: "Torrent count") + /// Torrent URL + internal static let torrentURL = L10n.tr("Localizable", "gallery_infos_view.title.torrent_URL", fallback: "Torrent URL") + /// Uploader + internal static let uploader = L10n.tr("Localizable", "gallery_infos_view.title.uploader", fallback: "Uploader") + /// Visibility + internal static let visibility = L10n.tr("Localizable", "gallery_infos_view.title.visibility", fallback: "Visibility") + } + internal enum Value { + /// No + internal static let no = L10n.tr("Localizable", "gallery_infos_view.value.no", fallback: "No") + /// None + internal static let `none` = L10n.tr("Localizable", "gallery_infos_view.value.none", fallback: "None") + /// Yes + internal static let yes = L10n.tr("Localizable", "gallery_infos_view.value.yes", fallback: "Yes") + } + } + internal enum GeneralSettingView { + internal enum Button { + /// Clear image caches + internal static let clearImageCaches = L10n.tr("Localizable", "general_setting_view.button.clear_image_caches", fallback: "Clear image caches") + /// Import custom translations + internal static let importCustomTranslations = L10n.tr("Localizable", "general_setting_view.button.import_custom_translations", fallback: "Import custom translations") + /// Logs + internal static let logs = L10n.tr("Localizable", "general_setting_view.button.logs", fallback: "Logs") + /// Remove custom translations + internal static let removeCustomTranslations = L10n.tr("Localizable", "general_setting_view.button.remove_custom_translations", fallback: "Remove custom translations") + } + internal enum Section { + internal enum Title { + /// Caches + internal static let caches = L10n.tr("Localizable", "general_setting_view.section.title.caches", fallback: "Caches") + /// Navigation + internal static let navigation = L10n.tr("Localizable", "general_setting_view.section.title.navigation", fallback: "Navigation") + /// Security + internal static let security = L10n.tr("Localizable", "general_setting_view.section.title.security", fallback: "Security") + /// Tags + internal static let tags = L10n.tr("Localizable", "general_setting_view.section.title.tags", fallback: "Tags") + } + } + internal enum Title { + /// Auto-Lock + internal static let autoLock = L10n.tr("Localizable", "general_setting_view.title.auto_lock", fallback: "Auto-Lock") + /// Background blur radius + internal static let backgroundBlurRadius = L10n.tr("Localizable", "general_setting_view.title.background_blur_radius", fallback: "Background blur radius") + /// Detects links from the clipboard + internal static let detectsLinksFromClipboard = L10n.tr("Localizable", "general_setting_view.title.detects_links_from_clipboard", fallback: "Detects links from the clipboard") + /// Enables tags extension + internal static let enablesTagsExtension = L10n.tr("Localizable", "general_setting_view.title.enables_tags_extension", fallback: "Enables tags extension") + /// General + internal static let general = L10n.tr("Localizable", "general_setting_view.title.general", fallback: "General") + /// Language + internal static let language = L10n.tr("Localizable", "general_setting_view.title.language", fallback: "Language") + /// Redirects links to the selected host + internal static let redirectsLinksToTheSelectedHost = L10n.tr("Localizable", "general_setting_view.title.redirects_links_to_the_selected_host", fallback: "Redirects links to the selected host") + /// Shows images in tags + internal static let showsImagesInTags = L10n.tr("Localizable", "general_setting_view.title.shows_images_in_tags", fallback: "Shows images in tags") + /// Shows tags search suggestion + internal static let showsTagsSearchSuggestion = L10n.tr("Localizable", "general_setting_view.title.shows_tags_search_suggestion", fallback: "Shows tags search suggestion") + /// Translates tags + internal static let translatesTags = L10n.tr("Localizable", "general_setting_view.title.translates_tags", fallback: "Translates tags") + } + internal enum Value { + /// N/A + internal static let defaultLanguageDescription = L10n.tr("Localizable", "general_setting_view.value.default_language_description", fallback: "N/A") + } + } + internal enum HistoryView { + internal enum Title { + /// History + internal static let history = L10n.tr("Localizable", "history_view.title.history", fallback: "History") + } + } + internal enum HomeView { + internal enum Section { + internal enum Title { + /// Frontpage + internal static let frontpage = L10n.tr("Localizable", "home_view.section.title.frontpage", fallback: "Frontpage") + /// Other + internal static let other = L10n.tr("Localizable", "home_view.section.title.other", fallback: "Other") + /// Toplists + internal static let toplists = L10n.tr("Localizable", "home_view.section.title.toplists", fallback: "Toplists") + } + } + internal enum Title { + /// Home + internal static let home = L10n.tr("Localizable", "home_view.title.home", fallback: "Home") + } + } + internal enum Hud { + internal enum Caption { + /// Copied to clipboard + internal static let copiedToClipboard = L10n.tr("Localizable", "hud.caption.copied_to_clipboard", fallback: "Copied to clipboard") + /// Saved to photo library + internal static let savedToPhotoLibrary = L10n.tr("Localizable", "hud.caption.saved_to_photo_library", fallback: "Saved to photo library") + } + internal enum Title { + /// Communicating... + internal static let communicating = L10n.tr("Localizable", "hud.title.communicating", fallback: "Communicating...") + /// Error + internal static let error = L10n.tr("Localizable", "hud.title.error", fallback: "Error") + /// Loading... + internal static let loading = L10n.tr("Localizable", "hud.title.loading", fallback: "Loading...") + /// Success + internal static let success = L10n.tr("Localizable", "hud.title.success", fallback: "Success") + } + } + internal enum JumpPageView { + internal enum Button { + /// Confirm + internal static let confirm = L10n.tr("Localizable", "jump_page_view.button.confirm", fallback: "Confirm") + } + internal enum Title { + /// Jump page + internal static let jumpPage = L10n.tr("Localizable", "jump_page_view.title.jump_page", fallback: "Jump page") + } + } + internal enum LaboratorySettingView { + internal enum Title { + /// Bypasses SNI Filtering + internal static let bypassesSNIFiltering = L10n.tr("Localizable", "laboratory_setting_view.title.bypasses_SNI_filtering", fallback: "Bypasses SNI Filtering") + /// Laboratory + internal static let laboratory = L10n.tr("Localizable", "laboratory_setting_view.title.laboratory", fallback: "Laboratory") + } + } + internal enum LoadingView { + internal enum Title { + /// Loading... + internal static let loading = L10n.tr("Localizable", "loading_view.title.loading", fallback: "Loading...") + /// Preparing the database... + internal static let preparingDatabase = L10n.tr("Localizable", "loading_view.title.preparing_database", fallback: "Preparing the database...") + } + } + internal enum LocalAuthorization { + /// The App has been locked due to the Auto-Lock expiration. + internal static let reason = L10n.tr("Localizable", "local_authorization.reason", fallback: "The App has been locked due to the Auto-Lock expiration.") + } + internal enum LoginView { + internal enum Title { + /// Login + internal static let login = L10n.tr("Localizable", "login_view.title.login", fallback: "Login") + /// Password + internal static let password = L10n.tr("Localizable", "login_view.title.password", fallback: "Password") + /// Username + internal static let username = L10n.tr("Localizable", "login_view.title.username", fallback: "Username") + } + } + internal enum LogsView { + internal enum Title { + /// Latest + internal static let latest = L10n.tr("Localizable", "logs_view.title.latest", fallback: "Latest") + /// Logs + internal static let logs = L10n.tr("Localizable", "logs_view.title.logs", fallback: "Logs") + } + } + internal enum NewDawnView { + internal enum Title { + /// It is the dawn of a new day! + internal static let first = L10n.tr("Localizable", "new_dawn_view.title.first", fallback: "It is the dawn of a new day!") + /// Reflecting on your journey so far, you find that you are a little wiser. + internal static let second = L10n.tr("Localizable", "new_dawn_view.title.second", fallback: "Reflecting on your journey so far, you find that you are a little wiser.") + } + } + internal enum NotLoginView { + internal enum Button { + /// Login + internal static let login = L10n.tr("Localizable", "not_login_view.button.login", fallback: "Login") + } + internal enum Title { + /// You need to login to access this feature. + internal static let needLogin = L10n.tr("Localizable", "not_login_view.title.need_login", fallback: "You need to login to access this feature.") + } + } + internal enum PopularView { + internal enum Title { + /// Popular + internal static let popular = L10n.tr("Localizable", "popular_view.title.popular", fallback: "Popular") + } + } + internal enum PostCommentView { + internal enum Button { + /// Cancel + internal static let cancel = L10n.tr("Localizable", "post_comment_view.button.cancel", fallback: "Cancel") + /// Post + internal static let post = L10n.tr("Localizable", "post_comment_view.button.post", fallback: "Post") + } + internal enum Title { + /// Edit comment + internal static let editComment = L10n.tr("Localizable", "post_comment_view.title.edit_comment", fallback: "Edit comment") + /// Post comment + internal static let postComment = L10n.tr("Localizable", "post_comment_view.title.post_comment", fallback: "Post comment") + } + } + internal enum PreviewsView { + internal enum Title { + /// Previews + internal static let previews = L10n.tr("Localizable", "previews_view.title.previews", fallback: "Previews") + } + } + internal enum QuickSearchView { + internal enum Placeholder { + /// Optional + internal static let `optional` = L10n.tr("Localizable", "quick_search_view.placeholder.optional", fallback: "Optional") + } + internal enum Title { + /// Content + internal static let content = L10n.tr("Localizable", "quick_search_view.title.content", fallback: "Content") + /// Edit word + internal static let editWord = L10n.tr("Localizable", "quick_search_view.title.edit_word", fallback: "Edit word") + /// Name + internal static let name = L10n.tr("Localizable", "quick_search_view.title.name", fallback: "Name") + /// New word + internal static let newWord = L10n.tr("Localizable", "quick_search_view.title.new_word", fallback: "New word") + /// Quick search + internal static let quickSearch = L10n.tr("Localizable", "quick_search_view.title.quick_search", fallback: "Quick search") + } + internal enum ToolbarItem { + internal enum Button { + /// Confirm + internal static let confirm = L10n.tr("Localizable", "quick_search_view.toolbar_item.button.confirm", fallback: "Confirm") + } + } + } + internal enum ReadingSettingView { + internal enum Section { + internal enum Title { + /// Appearance + internal static let appearance = L10n.tr("Localizable", "reading_setting_view.section.title.appearance", fallback: "Appearance") + } + } + internal enum Title { + /// Direction + internal static let direction = L10n.tr("Localizable", "reading_setting_view.title.direction", fallback: "Direction") + /// Double tap scale factor + internal static let doubleTapScaleFactor = L10n.tr("Localizable", "reading_setting_view.title.double_tap_scale_factor", fallback: "Double tap scale factor") + /// Enables landscape + internal static let enablesLandscape = L10n.tr("Localizable", "reading_setting_view.title.enables_landscape", fallback: "Enables landscape") + /// Maximum scale factor + internal static let maximumScaleFactor = L10n.tr("Localizable", "reading_setting_view.title.maximum_scale_factor", fallback: "Maximum scale factor") + /// Preload limit + internal static let preloadLimit = L10n.tr("Localizable", "reading_setting_view.title.preload_limit", fallback: "Preload limit") + /// Reading + internal static let reading = L10n.tr("Localizable", "reading_setting_view.title.reading", fallback: "Reading") + /// Separator height + internal static let separatorHeight = L10n.tr("Localizable", "reading_setting_view.title.separator_height", fallback: "Separator height") + } + } + internal enum ReadingView { + internal enum ContextMenu { + internal enum Button { + /// Copy + internal static let copy = L10n.tr("Localizable", "reading_view.context_menu.button.copy", fallback: "Copy") + /// Reload + internal static let reload = L10n.tr("Localizable", "reading_view.context_menu.button.reload", fallback: "Reload") + /// Save + internal static let save = L10n.tr("Localizable", "reading_view.context_menu.button.save", fallback: "Save") + /// Save original + internal static let saveOriginal = L10n.tr("Localizable", "reading_view.context_menu.button.save_original", fallback: "Save original") + /// Share + internal static let share = L10n.tr("Localizable", "reading_view.context_menu.button.share", fallback: "Share") + } + } + internal enum ToolbarItem { + internal enum Button { + /// Reading setting + internal static let readingSetting = L10n.tr("Localizable", "reading_view.toolbar_item.button.reading_setting", fallback: "Reading setting") + /// Reload all images + internal static let reloadAllImages = L10n.tr("Localizable", "reading_view.toolbar_item.button.reload_all_images", fallback: "Reload all images") + /// Retry all failed images + internal static let retryAllFailedImages = L10n.tr("Localizable", "reading_view.toolbar_item.button.retry_all_failed_images", fallback: "Retry all failed images") + } + internal enum Title { + /// Auto-Play + internal static let autoPlay = L10n.tr("Localizable", "reading_view.toolbar_item.title.auto_play", fallback: "Auto-Play") + /// Dual-Page mode + internal static let dualPageMode = L10n.tr("Localizable", "reading_view.toolbar_item.title.dual_page_mode", fallback: "Dual-Page mode") + /// Except the cover + internal static let exceptTheCover = L10n.tr("Localizable", "reading_view.toolbar_item.title.except_the_cover", fallback: "Except the cover") + } + } + } + internal enum SearchView { + internal enum Section { + internal enum Title { + /// Quick search + internal static let quickSearch = L10n.tr("Localizable", "search_view.section.title.quick_search", fallback: "Quick search") + /// Recently searched + internal static let recentlySearched = L10n.tr("Localizable", "search_view.section.title.recently_searched", fallback: "Recently searched") + /// Recently seen + internal static let recentlySeen = L10n.tr("Localizable", "search_view.section.title.recently_seen", fallback: "Recently seen") + } + } + internal enum Title { + /// Search + internal static let search = L10n.tr("Localizable", "search_view.title.search", fallback: "Search") + } + } + internal enum Searchable { + internal enum Prompt { + /// Filter + internal static let filter = L10n.tr("Localizable", "searchable.prompt.filter", fallback: "Filter") + } + internal enum Title { + /// Found %d matches. + internal static func matchesCount(_ p1: Int) -> String { + return L10n.tr("Localizable", "searchable.title.matches_count", p1, fallback: "Found %d matches.") + } + } + } + internal enum SettingView { + internal enum Title { + /// Setting + internal static let setting = L10n.tr("Localizable", "setting_view.title.setting", fallback: "Setting") + } + } + internal enum Struct { + internal enum CookieValue { + internal enum LocalizedString { + /// Expired + internal static let expired = L10n.tr("Localizable", "struct.cookie_value.localized_string.expired", fallback: "Expired") + /// Rejected + internal static let mystery = L10n.tr("Localizable", "struct.cookie_value.localized_string.mystery", fallback: "Rejected") + /// None + internal static let `none` = L10n.tr("Localizable", "struct.cookie_value.localized_string.none", fallback: "None") + } + } + internal enum Greeting { + internal enum Mark { + /// and + internal static let and = L10n.tr("Localizable", "struct.greeting.mark.and", fallback: " and ") + /// ! + internal static let end = L10n.tr("Localizable", "struct.greeting.mark.end", fallback: "!") + /// , + internal static let separator = L10n.tr("Localizable", "struct.greeting.mark.separator", fallback: ", ") + /// You gain + internal static let start = L10n.tr("Localizable", "struct.greeting.mark.start", fallback: "You gain ") + } + } + internal enum HathArchive { + internal enum Price { + /// Free + internal static let free = L10n.tr("Localizable", "struct.hath_archive.price.free", fallback: "Free") + /// N/A + internal static let notAvailable = L10n.tr("Localizable", "struct.hath_archive.price.not_available", fallback: "N/A") + } + } + internal enum User { + internal enum FavoriteCategory { + /// All + internal static let all = L10n.tr("Localizable", "struct.user.favorite_category.all", fallback: "All") + /// Favorites %@ + internal static func `default`(_ p1: Any) -> String { + return L10n.tr("Localizable", "struct.user.favorite_category.default", String(describing: p1), fallback: "Favorites %@") + } + } + } + } + internal enum SubSection { + internal enum Button { + /// Show all + internal static let showAll = L10n.tr("Localizable", "sub_section.button.show_all", fallback: "Show all") + } + } + internal enum TabItem { + internal enum Title { + /// Favorites + internal static let favorites = L10n.tr("Localizable", "tab_item.title.favorites", fallback: "Favorites") + /// Home + internal static let home = L10n.tr("Localizable", "tab_item.title.home", fallback: "Home") + /// Search + internal static let search = L10n.tr("Localizable", "tab_item.title.search", fallback: "Search") + /// Setting + internal static let setting = L10n.tr("Localizable", "tab_item.title.setting", fallback: "Setting") + } + } + internal enum TagDetailView { + internal enum Section { + internal enum Title { + /// Images + internal static let images = L10n.tr("Localizable", "tag_detail_view.section.title.images", fallback: "Images") + /// Links + internal static let links = L10n.tr("Localizable", "tag_detail_view.section.title.links", fallback: "Links") + } + } + } + internal enum ToolbarItem { + internal enum Button { + /// Filters + internal static let filters = L10n.tr("Localizable", "toolbar_item.button.filters", fallback: "Filters") + /// Jump page + internal static let jumpPage = L10n.tr("Localizable", "toolbar_item.button.jump_page", fallback: "Jump page") + /// Quick search + internal static let quickSearch = L10n.tr("Localizable", "toolbar_item.button.quick_search", fallback: "Quick search") + } + } + internal enum ToplistsView { + internal enum Title { + /// Toplists + internal static let toplists = L10n.tr("Localizable", "toplists_view.title.toplists", fallback: "Toplists") + } + } + internal enum TorrentsView { + internal enum Title { + /// Torrents + internal static let torrents = L10n.tr("Localizable", "torrents_view.title.torrents", fallback: "Torrents") + } + } + internal enum WatchedView { + internal enum Title { + /// Watched + internal static let watched = L10n.tr("Localizable", "watched_view.title.watched", fallback: "Watched") + } + } + internal enum Website { + internal enum Response { + /// You must have a H@H client assigned to your account to use this feature. + internal static let hathClientNotFound = L10n.tr("Localizable", "website.response.hath_client_not_found", fallback: "You must have a H@H client assigned to your account to use this feature.") + /// Your H@H client appears to be offline. Turn it on, then try again. + internal static let hathClientNotOnline = L10n.tr("Localizable", "website.response.hath_client_not_online", fallback: "Your H@H client appears to be offline. Turn it on, then try again.") + /// The requested gallery cannot be downloaded with the selected resolution. + internal static let invalidResolution = L10n.tr("Localizable", "website.response.invalid_resolution", fallback: "The requested gallery cannot be downloaded with the selected resolution.") + } + } + } +} +// swiftlint:enable explicit_type_interface function_parameter_count identifier_name line_length +// swiftlint:enable nesting type_body_length type_name vertical_whitespace_opening_braces + +// MARK: - Implementation Details + +extension L10n { + private static func tr(_ table: String, _ key: String, _ args: CVarArg..., fallback value: String) -> String { + let format = BundleToken.bundle.localizedString(forKey: key, value: value, table: table) + return String(format: format, locale: Locale.current, arguments: args) + } +} + +// swiftlint:disable convenience_type +private final class BundleToken { + static let bundle: Bundle = { + #if SWIFT_PACKAGE + return Bundle.module + #else + return Bundle(for: BundleToken.self) + #endif + }() +} +// swiftlint:enable convenience_type