From c3096e5dfe883cc4609887100eb860b890b89343 Mon Sep 17 00:00:00 2001 From: Jackson Harper Date: Wed, 25 May 2022 21:33:55 -0700 Subject: [PATCH 1/5] Better PDF upload handling on iOS Three main changes here: - If a PDF isn't a local file, dont try to download and then upload it to the backend. Just treat it as a URL. - If we are passed PDF data by an app like Files, upload it. - Wrap the whole operation in a Background task so its not killed if the user taps dismiss during the upload of larger documents. --- .../Share/ShareExtensionScene.swift | 16 ++- .../Sources/Models/PageScrapePayload.swift | 97 +++++++++++++++---- .../DataService/Mutations/SaveArticle.swift | 12 ++- .../DataService/Mutations/SavePDF.swift | 9 +- .../DataService/Mutations/SavePage.swift | 6 +- 5 files changed, 105 insertions(+), 35 deletions(-) diff --git a/apple/OmnivoreKit/Sources/App/AppExtensions/Share/ShareExtensionScene.swift b/apple/OmnivoreKit/Sources/App/AppExtensions/Share/ShareExtensionScene.swift index 39696dd35..d3fa98d5f 100644 --- a/apple/OmnivoreKit/Sources/App/AppExtensions/Share/ShareExtensionScene.swift +++ b/apple/OmnivoreKit/Sources/App/AppExtensions/Share/ShareExtensionScene.swift @@ -59,11 +59,17 @@ final class ShareExtensionViewModel: ObservableObject { return } + let backgroundTask = UIApplication.shared.beginBackgroundTask(withName: requestId) let saveLinkPublisher: AnyPublisher = { - if pageScrapePayload.contentType == .pdf { - return services.dataService.uploadPDFPublisher(pageScrapePayload: pageScrapePayload, requestId: requestId) - } else if pageScrapePayload.html != nil { - return services.dataService.savePagePublisher(pageScrapePayload: pageScrapePayload, requestId: requestId) + if case let .pdf(data) = pageScrapePayload.contentType { + return services.dataService.uploadPDFPublisher(pageScrapePayload: pageScrapePayload, + data: data, + requestId: requestId) + } else if case let .html(html, title) = pageScrapePayload.contentType { + return services.dataService.savePagePublisher(pageScrapePayload: pageScrapePayload, + html: html, + title: title, + requestId: requestId) } else { return services.dataService.saveUrlPublisher(pageScrapePayload: pageScrapePayload, requestId: requestId) } @@ -74,8 +80,10 @@ final class ShareExtensionViewModel: ObservableObject { guard case let .failure(error) = completion else { return } self?.debugText = "saveArticleError: \(error)" self?.status = .failed(error: error) + UIApplication.shared.endBackgroundTask(backgroundTask) } receiveValue: { [weak self] _ in self?.status = .success + UIApplication.shared.endBackgroundTask(backgroundTask) } .store(in: &subscriptions) diff --git a/apple/OmnivoreKit/Sources/Models/PageScrapePayload.swift b/apple/OmnivoreKit/Sources/Models/PageScrapePayload.swift index edf1baa42..27b051346 100644 --- a/apple/OmnivoreKit/Sources/Models/PageScrapePayload.swift +++ b/apple/OmnivoreKit/Sources/Models/PageScrapePayload.swift @@ -9,28 +9,34 @@ import UniformTypeIdentifiers let URLREGEX = #"[(http(s)?):\/\/(www\.)?a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)"# public struct PageScrapePayload { - public enum ContentType { - case html - case pdf + public struct HTMLPayload { + let url: String + let title: String? + let html: String + } + + public enum ContentType { + case none + case html(html: String, title: String?) + case pdf(data: Data) } - public let title: String? - public let html: String? public let url: String public let contentType: ContentType - init(url: String, title: String?, html: String?, contentType: String?) { + init(url: String) { self.url = url - self.title = title - self.html = html + self.contentType = .none + } - // If the content type was specified and we know its PDF, use that - // otherwise fallback to using file extensions. - if let contentType = contentType, contentType.contains("pdf") { - self.contentType = .pdf - } else { - self.contentType = url.hasSuffix(".pdf") ? .pdf : .html - } + init(url: String, pdfData: Data) { + self.url = url + self.contentType = .pdf(data: pdfData) + } + + init(url: String, title: String?, html: String) { + self.url = url + self.contentType = .html(html: html, title: title) } } @@ -52,10 +58,25 @@ public enum PageScraper { } var pageScrapePayload: PageScrapePayload? + let PDFKey = UTType.pdf.identifier + let publicFileKey = UTType.fileURL.identifier let propertyListKey = UTType.propertyList.identifier let group = DispatchGroup() + for attachment in attachments where attachment.hasItemConformingToTypeIdentifier(PDFKey) { + group.enter() + attachment.loadItem( + forTypeIdentifier: PDFKey, + options: nil + ) { item, _ in + if let payload = PageScrapePayload.make(item: item) { + pageScrapePayload = payload + } + group.leave() + } + } + for attachment in attachments where attachment.hasItemConformingToTypeIdentifier(propertyListKey) { group.enter() attachment.loadItem( @@ -214,17 +235,55 @@ public enum PageScraper { private extension PageScrapePayload { static func make(url: URL?) -> PageScrapePayload? { guard let url = url else { return nil } - return PageScrapePayload(url: url.absoluteString, title: nil, html: nil, contentType: nil) + return PageScrapePayload(url: url.absoluteString) } static func make(item: NSSecureCoding?) -> PageScrapePayload? { - let dictionary = item as? NSDictionary - let results = dictionary?[NSExtensionJavaScriptPreprocessingResultsKey] as? NSDictionary + if let dictionary = item as? NSDictionary { + return makeFromDictionary(dictionary) + } + if let url = item as? NSURL { + return makeFromURL(url as URL) + } + return nil + } + + static func makeFromURL(_ url: URL) -> PageScrapePayload? { + if url.isFileURL { + let type = try? url.resourceValues(forKeys: [.typeIdentifierKey]).typeIdentifier + if type == UTType.pdf.identifier, let data = try? Data(contentsOf: url) { + return PageScrapePayload(url: url.absoluteString, pdfData: data) + } + // Don't try to handle file URLs that are not PDFs. + // In the future we can add image and other file type support here + return nil + } + return PageScrapePayload(url: url.absoluteString) + } + + static func makeFromDictionary(_ dictionary: NSDictionary) -> PageScrapePayload? { + let results = dictionary[NSExtensionJavaScriptPreprocessingResultsKey] as? NSDictionary guard let url = results?["url"] as? String else { return nil } let html = results?["documentHTML"] as? String let title = results?["title"] as? String let contentType = results?["contentType"] as? String - return PageScrapePayload(url: url, title: title, html: html, contentType: contentType) + // If we were not able to capture any HTML, treat this as a URL and + // see if the backend can do better. + if html == nil || html!.isEmpty { + return PageScrapePayload(url: url) + } + + // If its a PDF that we opened through Safari we don't have access to the + // file content, so pass the URL to the backend and let it download it. + if contentType == "application/pdf" { + return PageScrapePayload(url: url) + } + + if let html = html { + return PageScrapePayload(url: url, title: title, html: html) + } + + return PageScrapePayload(url: url) } } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SaveArticle.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SaveArticle.swift index 3ca426ca2..cdb5a7a38 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SaveArticle.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SaveArticle.swift @@ -92,11 +92,13 @@ public extension DataService { } let preparedDocument: InputObjects.PreparedDocumentInput? = { - guard let html = pageScrapePayload.html, let title = pageScrapePayload.title else { return nil } - return InputObjects.PreparedDocumentInput( - document: html, - pageInfo: InputObjects.PageInfoInput(title: OptionalArgument(title)) - ) + if case let .html(html, title) = pageScrapePayload.contentType { + return InputObjects.PreparedDocumentInput( + document: html, + pageInfo: InputObjects.PageInfoInput(title: OptionalArgument(title)) + ) + } + return nil }() let input = InputObjects.CreateArticleInput( diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePDF.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePDF.swift index 431dd2f1e..058953ba1 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePDF.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePDF.swift @@ -6,10 +6,11 @@ import SwiftGraphQL public extension DataService { func uploadPDFPublisher( pageScrapePayload: PageScrapePayload, + data: Data, requestId: String ) -> AnyPublisher { uploadFileRequestPublisher(pageScrapePayload: pageScrapePayload) - .flatMap { self.uploadFilePublisher(fileUploadConfig: $0, fileURLString: pageScrapePayload.url) } + .flatMap { self.uploadFilePublisher(fileUploadConfig: $0, data: data) } .flatMap { self.saveFilePublisher(pageScrapePayload: pageScrapePayload, uploadFileId: $0, requestId: requestId) } .catch { _ in self.saveUrlPublisher(pageScrapePayload: pageScrapePayload, requestId: requestId) } .receive(on: DispatchQueue.main) @@ -88,11 +89,11 @@ private extension DataService { } // swiftlint:disable:next line_length - func uploadFilePublisher(fileUploadConfig: UploadFileRequestPayload, fileURLString: String) -> AnyPublisher { - let pdfData = URL(string: fileURLString).flatMap { try? Data(contentsOf: $0) } + func uploadFilePublisher(fileUploadConfig: UploadFileRequestPayload, data: Data) -> AnyPublisher { + let pdfData = data // URL(string: "http://localhost:4000/local/debug/endpoint").flatMap { try? Data(contentsOf: $0) } let url = fileUploadConfig.urlString.flatMap { URL(string: $0) } - guard let url = url, let pdfData = pdfData else { return Future { $0(.failure(.badData)) }.eraseToAnyPublisher() } + guard let url = url else { return Future { $0(.failure(.badData)) }.eraseToAnyPublisher() } var request = URLRequest(url: url) request.httpMethod = "PUT" diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePage.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePage.swift index cda9a6e9e..7a8ccad53 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePage.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePage.swift @@ -5,7 +5,7 @@ import SwiftGraphQL public extension DataService { // swiftlint:disable:next line_length - func savePagePublisher(pageScrapePayload: PageScrapePayload, requestId: String) -> AnyPublisher { + func savePagePublisher(pageScrapePayload: PageScrapePayload, html: String, title: String?, requestId: String) -> AnyPublisher { enum MutationResult { case saved(requestId: String, url: String) case error(errorCode: Enums.SaveErrorCode) @@ -13,9 +13,9 @@ public extension DataService { let input = InputObjects.SavePageInput( clientRequestId: requestId, - originalContent: pageScrapePayload.html ?? "", + originalContent: html, source: "ios-page", - title: OptionalArgument(pageScrapePayload.title), + title: OptionalArgument(title), url: pageScrapePayload.url ) From cb98a9cf8618da31f076e1f4ac7171d22b189715 Mon Sep 17 00:00:00 2001 From: Jackson Harper Date: Thu, 26 May 2022 13:35:30 -0700 Subject: [PATCH 2/5] Make clients opt into creating a page when uploading a file --- packages/api/src/generated/graphql.ts | 2 + packages/api/src/generated/schema.graphql | 2 + packages/api/src/resolvers/article/index.ts | 5 +- .../api/src/resolvers/upload_files/index.ts | 56 +++++++++++-------- packages/api/src/schema.ts | 3 + packages/api/src/utils/helpers.ts | 12 ++++ packages/content-fetch/fetch-content.js | 9 +-- 7 files changed, 62 insertions(+), 27 deletions(-) diff --git a/packages/api/src/generated/graphql.ts b/packages/api/src/generated/graphql.ts index 201e76621..e45789319 100644 --- a/packages/api/src/generated/graphql.ts +++ b/packages/api/src/generated/graphql.ts @@ -1992,7 +1992,9 @@ export enum UploadFileRequestErrorCode { } export type UploadFileRequestInput = { + clientRequestId?: InputMaybe; contentType: Scalars['String']; + createPageEntry?: InputMaybe; url: Scalars['String']; }; diff --git a/packages/api/src/generated/schema.graphql b/packages/api/src/generated/schema.graphql index d6c81bf3e..752593100 100644 --- a/packages/api/src/generated/schema.graphql +++ b/packages/api/src/generated/schema.graphql @@ -1535,7 +1535,9 @@ enum UploadFileRequestErrorCode { } input UploadFileRequestInput { + clientRequestId: String contentType: String! + createPageEntry: Boolean url: String! } diff --git a/packages/api/src/resolvers/article/index.ts b/packages/api/src/resolvers/article/index.ts index 1250a9a01..c0dde0344 100644 --- a/packages/api/src/resolvers/article/index.ts +++ b/packages/api/src/resolvers/article/index.ts @@ -51,6 +51,7 @@ import { stringToHash, userDataToUser, validatedDate, + titleForFilePath, } from '../../utils/helpers' import { ParsedContentPuppeteer, @@ -166,6 +167,7 @@ export const createArticleResolver = authorized< .join('.') ).replace(/_/gi, ' ') + let title: string | undefined let parsedContent: Readability.ParseResult | null = null let canonicalUrl let userArticleUrl: string | null = null @@ -219,6 +221,7 @@ export const createArticleResolver = authorized< userArticleUrl = uploadFileDetails.fileUrl canonicalUrl = uploadFile.url pageType = PageType.File + title = titleForFilePath(uploadFile.url) } else if ( source !== 'puppeteer-parse' && FORCE_PUPPETEER_URLS.some((regex) => regex.test(url)) @@ -252,6 +255,7 @@ export const createArticleResolver = authorized< content: parsedContent?.content || '', description: parsedContent?.excerpt || '', title: + title || parsedContent?.title || preparedDocument?.pageInfo.title || croppedPathname, @@ -333,7 +337,6 @@ export const createArticleResolver = authorized< } else { // update existing page's state from processing to succeeded articleToSave.archivedAt = archive ? saveTime : undefined - articleToSave.url = uploadFileUrlOverride || articleToSave.url const updated = await updatePage(pageId, articleToSave, { ...ctx, uid, diff --git a/packages/api/src/resolvers/upload_files/index.ts b/packages/api/src/resolvers/upload_files/index.ts index 4e0c4cb63..3a6a58fa5 100644 --- a/packages/api/src/resolvers/upload_files/index.ts +++ b/packages/api/src/resolvers/upload_files/index.ts @@ -16,7 +16,7 @@ import path from 'path' import normalizeUrl from 'normalize-url' import { analytics } from '../../utils/analytics' import { env } from '../../env' -import { createPage } from '../../elastic/pages' +import { createPage, getPageByParam, updatePage } from '../../elastic/pages' import { PageType } from '../../elastic/types' import { generateSlug } from '../../utils/helpers' @@ -82,28 +82,40 @@ export const uploadFileRequestResolver: ResolverFn< input.contentType ) - const pageId = await createPage( - { - id: '', - url: input.url, + if (input.createPageEntry) { + let page = await getPageByParam({ userId: claims.uid, - title: title, - hash: uploadFilePathName, - content: '', - pageType: PageType.File, - uploadFileId: uploadFileData.id, - slug: generateSlug(uploadFilePathName), - createdAt: new Date(), - savedAt: new Date(), - readingProgressPercent: 0, - readingProgressAnchorIndex: 0, - state: ArticleSavingRequestStatus.Processing, - }, - ctx - ) - - if (!pageId) { - return { errorCodes: [UploadFileRequestErrorCode.FailedCreate] } + url: input.url, + }) + if (page) { + await updatePage(page.id, { + savedAt: new Date(), + archivedAt: null, + }, ctx) + } else { + const pageId = await createPage( + { + url: input.url, + id: input.clientRequestId || '', + userId: claims.uid, + title: title, + hash: uploadFilePathName, + content: '', + pageType: PageType.File, + uploadFileId: uploadFileData.id, + slug: generateSlug(uploadFilePathName), + createdAt: new Date(), + savedAt: new Date(), + readingProgressPercent: 0, + readingProgressAnchorIndex: 0, + state: ArticleSavingRequestStatus.Processing, + }, + ctx + ) + if (!pageId) { + return { errorCodes: [UploadFileRequestErrorCode.FailedCreate] } + } + } } return { id: uploadFileData.id, uploadSignedUrl } diff --git a/packages/api/src/schema.ts b/packages/api/src/schema.ts index 2a0e8959a..1dc5174ea 100755 --- a/packages/api/src/schema.ts +++ b/packages/api/src/schema.ts @@ -416,7 +416,10 @@ const schema = gql` input UploadFileRequestInput { url: String! contentType: String! + createPageEntry: Boolean + clientRequestId: String } + enum UploadFileRequestErrorCode { UNAUTHORIZED BAD_INPUT diff --git a/packages/api/src/utils/helpers.ts b/packages/api/src/utils/helpers.ts index 73c0abdc9..8a54e3a5e 100644 --- a/packages/api/src/utils/helpers.ts +++ b/packages/api/src/utils/helpers.ts @@ -18,6 +18,8 @@ import { Merge } from '../util' import { CreateArticlesSuccessPartial } from '../resolvers' import { ArticleSavingRequestStatus, Page } from '../elastic/types' import { updatePage } from '../elastic/pages' +import path from 'path' +import normalizeUrl from 'normalize-url' interface InputObject { // eslint-disable-next-line @typescript-eslint/no-explicit-any @@ -230,3 +232,13 @@ export const validatedDate = ( return undefined } } + +export const titleForFilePath = (url: string): string => { + try { + const title = decodeURI(path.basename(new URL(url).pathname, '.pdf')) + return title + } catch (e) { + console.log(e) + } + return url +} diff --git a/packages/content-fetch/fetch-content.js b/packages/content-fetch/fetch-content.js index 1c948fccc..fd9a51b56 100644 --- a/packages/content-fetch/fetch-content.js +++ b/packages/content-fetch/fetch-content.js @@ -94,7 +94,7 @@ const uploadToSignedUrl = async ({ id, uploadSignedUrl }, contentType, contentOb }) }; -const getUploadIdAndSignedUrl = async (userId, url) => { +const getUploadIdAndSignedUrl = async (userId, url, articleSavingRequestId) => { const auth = await signToken({ uid: userId }, process.env.JWT_SECRET); const data = JSON.stringify({ query: `mutation UploadFileRequest($input: UploadFileRequestInput!) { @@ -112,6 +112,7 @@ const getUploadIdAndSignedUrl = async (userId, url) => { input: { url, contentType: 'application/pdf', + clientRequestId: articleSavingRequestId, } } }); @@ -126,10 +127,10 @@ const getUploadIdAndSignedUrl = async (userId, url) => { return response.data.data.uploadFileRequest; }; -const uploadPdf = async (url, userId) => { +const uploadPdf = async (url, userId, articleSavingRequestId) => { validateUrlString(url); - const uploadResult = await getUploadIdAndSignedUrl(userId, url); + const uploadResult = await getUploadIdAndSignedUrl(userId, url, articleSavingRequestId); await uploadToSignedUrl(uploadResult, 'application/pdf', url); return uploadResult.id; }; @@ -282,7 +283,7 @@ async function fetchContent(req, res) { try { if (contentType === 'application/pdf') { - const uploadedFileId = await uploadPdf(finalUrl, userId); + const uploadedFileId = await uploadPdf(finalUrl, userId, articleSavingRequestId); const l = await saveUploadedPdf(userId, finalUrl, uploadedFileId, articleSavingRequestId); } else { if (!content || !title) { From 93b095818dc43b93d784ff8fb63b72d3c1281e20 Mon Sep 17 00:00:00 2001 From: Jackson Harper Date: Thu, 26 May 2022 13:46:42 -0700 Subject: [PATCH 3/5] Linting fixes --- packages/api/src/resolvers/upload_files/index.ts | 14 +++++++++----- packages/api/src/services/save_file.ts | 12 ++---------- packages/api/src/utils/helpers.ts | 2 +- 3 files changed, 12 insertions(+), 16 deletions(-) diff --git a/packages/api/src/resolvers/upload_files/index.ts b/packages/api/src/resolvers/upload_files/index.ts index 3a6a58fa5..0fb38ea06 100644 --- a/packages/api/src/resolvers/upload_files/index.ts +++ b/packages/api/src/resolvers/upload_files/index.ts @@ -83,15 +83,19 @@ export const uploadFileRequestResolver: ResolverFn< ) if (input.createPageEntry) { - let page = await getPageByParam({ + const page = await getPageByParam({ userId: claims.uid, url: input.url, }) if (page) { - await updatePage(page.id, { - savedAt: new Date(), - archivedAt: null, - }, ctx) + await updatePage( + page.id, + { + savedAt: new Date(), + archivedAt: null, + }, + ctx + ) } else { const pageId = await createPage( { diff --git a/packages/api/src/services/save_file.ts b/packages/api/src/services/save_file.ts index cc7688b34..c7248ef44 100644 --- a/packages/api/src/services/save_file.ts +++ b/packages/api/src/services/save_file.ts @@ -2,17 +2,9 @@ import Knex from 'knex' import { PubsubClient } from '../datalayer/pubsub' import { UserData } from '../datalayer/user/model' import { homePageURL } from '../env' -import { - PageType, - SaveErrorCode, - SaveFileInput, - SaveResult, -} from '../generated/graphql' +import { SaveErrorCode, SaveFileInput, SaveResult } from '../generated/graphql' import { DataModels } from '../resolvers/types' -import { generateSlug } from '../utils/helpers' -import { getStorageFileDetails, makeStorageFilePublic } from '../utils/uploads' -import { createPage, getPageByParam, updatePage } from '../elastic/pages' -import { ArticleSavingRequestStatus } from '../elastic/types' +import { getStorageFileDetails } from '../utils/uploads' type SaveContext = { pubsub: PubsubClient diff --git a/packages/api/src/utils/helpers.ts b/packages/api/src/utils/helpers.ts index 8a54e3a5e..0a5305e13 100644 --- a/packages/api/src/utils/helpers.ts +++ b/packages/api/src/utils/helpers.ts @@ -235,7 +235,7 @@ export const validatedDate = ( export const titleForFilePath = (url: string): string => { try { - const title = decodeURI(path.basename(new URL(url).pathname, '.pdf')) + const title = decodeURI(path.basename(new URL(url).pathname, '.pdf')) return title } catch (e) { console.log(e) From 0cabd263444e0b0057ad92ba0e3e36cf2fbf93ba Mon Sep 17 00:00:00 2001 From: Jackson Harper Date: Thu, 26 May 2022 16:04:21 -0700 Subject: [PATCH 4/5] Dont send the normalized URL to the content-fetch service URLs need to be sent to contentFetch exactly as they were received, this is because many apps will use signed URLs for PDFs being served from GCP or AWS. A signed URL needs to keep all its query params in the same order to validate. --- packages/api/src/services/create_page_save_request.ts | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/packages/api/src/services/create_page_save_request.ts b/packages/api/src/services/create_page_save_request.ts index ca8c0c357..60a7e5672 100644 --- a/packages/api/src/services/create_page_save_request.ts +++ b/packages/api/src/services/create_page_save_request.ts @@ -83,13 +83,14 @@ export const createPageSaveRequest = async ( priority = priority || (await getPriorityByRateLimit(userId)) // look for existing page - url = normalizeUrl(url, { + const normalizedUrl = normalizeUrl(url, { stripHash: true, stripWWW: false, }) + let page = await getPageByParam({ userId, - url, + url: normalizedUrl, }) if (page) { console.log('Page already exists', page) From 4376124028c3132d1a07fc3f306ca8f98c1908f2 Mon Sep 17 00:00:00 2001 From: Jackson Harper Date: Thu, 26 May 2022 21:34:59 -0700 Subject: [PATCH 5/5] Regenerate GQL, set createPageEntry when uploading files --- .../Services/DataService/GQLSchema.swift | 33354 ++++++++-------- .../DataService/Mutations/ArchiveLink.swift | 8 +- .../Mutations/CreateHighlight.swift | 10 +- .../Mutations/CreateLabelPublisher.swift | 8 +- .../CreateNewsletterEmailMutation.swift | 6 +- .../Mutations/CreateReminder.swift | 12 +- .../Mutations/DeleteHighlight.swift | 4 +- .../Mutations/DeleteSubscription.swift | 4 +- .../DataService/Mutations/DeviceToken.swift | 4 +- .../Mutations/MergeHighlight.swift | 18 +- .../Mutations/RemoveLabelPublisher.swift | 4 +- .../DataService/Mutations/RemoveLink.swift | 4 +- .../DataService/Mutations/SaveArticle.swift | 16 +- .../DataService/Mutations/SavePDF.swift | 26 +- .../DataService/Mutations/SavePage.swift | 11 +- .../DataService/Mutations/SaveUrl.swift | 8 +- .../UpdateArticleLabelsPublisher.swift | 8 +- .../UpdateArticleReadingProgress.swift | 8 +- .../Mutations/UpdateHighlightAttributes.swift | 6 +- .../Queries/ArticleContentQuery.swift | 11 +- .../DataService/Queries/LabelsPublisher.swift | 6 +- .../Queries/LibraryItemsQuery.swift | 52 +- .../Queries/LinkedItemIDsQuery.swift | 6 +- .../Queries/NewsletterEmailsQuery.swift | 6 +- .../Queries/SubscriptionsQuery.swift | 6 +- 25 files changed, 16839 insertions(+), 16767 deletions(-) diff --git a/apple/OmnivoreKit/Sources/Services/DataService/GQLSchema.swift b/apple/OmnivoreKit/Sources/Services/DataService/GQLSchema.swift index d2faed4b9..bc0c03406 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/GQLSchema.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/GQLSchema.swift @@ -21,17 +21,924 @@ extension Objects.Subscription: GraphQLWebSocketOperation { enum Objects {} extension Objects { - struct AddPopularReadError { - let __typename: TypeName = .addPopularReadError - let errorCodes: [String: [Enums.AddPopularReadErrorCode]] + struct PageInfo { + let __typename: TypeName = .pageInfo + let endCursor: [String: String] + let hasNextPage: [String: Bool] + let hasPreviousPage: [String: Bool] + let startCursor: [String: String] + let totalCount: [String: Int] enum TypeName: String, Codable { - case addPopularReadError = "AddPopularReadError" + case pageInfo = "PageInfo" } } } -extension Objects.AddPopularReadError: Decodable { +extension Objects.PageInfo: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "endCursor": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "hasNextPage": + if let value = try container.decode(Bool?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "hasPreviousPage": + if let value = try container.decode(Bool?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "startCursor": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "totalCount": + if let value = try container.decode(Int?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + endCursor = map["endCursor"] + hasNextPage = map["hasNextPage"] + hasPreviousPage = map["hasPreviousPage"] + startCursor = map["startCursor"] + totalCount = map["totalCount"] + } +} + +extension Fields where TypeLock == Objects.PageInfo { + func hasNextPage() throws -> Bool { + let field = GraphQLField.leaf( + name: "hasNextPage", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.hasNextPage[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Bool.mockValue + } + } + + func hasPreviousPage() throws -> Bool { + let field = GraphQLField.leaf( + name: "hasPreviousPage", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.hasPreviousPage[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Bool.mockValue + } + } + + func startCursor() throws -> String? { + let field = GraphQLField.leaf( + name: "startCursor", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.startCursor[field.alias!] + case .mocking: + return nil + } + } + + func endCursor() throws -> String? { + let field = GraphQLField.leaf( + name: "endCursor", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.endCursor[field.alias!] + case .mocking: + return nil + } + } + + func totalCount() throws -> Int? { + let field = GraphQLField.leaf( + name: "totalCount", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.totalCount[field.alias!] + case .mocking: + return nil + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias PageInfo = Selection +} + +extension Objects { + struct ArticleEdge { + let __typename: TypeName = .articleEdge + let cursor: [String: String] + let node: [String: Objects.Article] + + enum TypeName: String, Codable { + case articleEdge = "ArticleEdge" + } + } +} + +extension Objects.ArticleEdge: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "cursor": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "node": + if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + cursor = map["cursor"] + node = map["node"] + } +} + +extension Fields where TypeLock == Objects.ArticleEdge { + func cursor() throws -> String { + let field = GraphQLField.leaf( + name: "cursor", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.cursor[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func node(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "node", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.node[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ArticleEdge = Selection +} + +extension Objects { + struct FeedArticleEdge { + let __typename: TypeName = .feedArticleEdge + let cursor: [String: String] + let node: [String: Objects.FeedArticle] + + enum TypeName: String, Codable { + case feedArticleEdge = "FeedArticleEdge" + } + } +} + +extension Objects.FeedArticleEdge: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "cursor": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "node": + if let value = try container.decode(Objects.FeedArticle?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + cursor = map["cursor"] + node = map["node"] + } +} + +extension Fields where TypeLock == Objects.FeedArticleEdge { + func cursor() throws -> String { + let field = GraphQLField.leaf( + name: "cursor", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.cursor[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func node(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "node", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.node[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias FeedArticleEdge = Selection +} + +extension Objects { + struct ArticlesSuccess { + let __typename: TypeName = .articlesSuccess + let edges: [String: [Objects.ArticleEdge]] + let pageInfo: [String: Objects.PageInfo] + + enum TypeName: String, Codable { + case articlesSuccess = "ArticlesSuccess" + } + } +} + +extension Objects.ArticlesSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "edges": + if let value = try container.decode([Objects.ArticleEdge]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "pageInfo": + if let value = try container.decode(Objects.PageInfo?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + edges = map["edges"] + pageInfo = map["pageInfo"] + } +} + +extension Fields where TypeLock == Objects.ArticlesSuccess { + func edges(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "edges", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.edges[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func pageInfo(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "pageInfo", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.pageInfo[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ArticlesSuccess = Selection +} + +extension Objects { + struct User { + let __typename: TypeName = .user + let followersCount: [String: Int] + let friendsCount: [String: Int] + let id: [String: String] + let isFriend: [String: Bool] + let isFullUser: [String: Bool] + let name: [String: String] + let picture: [String: String] + let profile: [String: Objects.Profile] + let sharedArticles: [String: [Objects.FeedArticle]] + let sharedArticlesCount: [String: Int] + let sharedHighlightsCount: [String: Int] + let sharedNotesCount: [String: Int] + let viewerIsFollowing: [String: Bool] + + enum TypeName: String, Codable { + case user = "User" + } + } +} + +extension Objects.User: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "followersCount": + if let value = try container.decode(Int?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "friendsCount": + if let value = try container.decode(Int?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "id": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "isFriend": + if let value = try container.decode(Bool?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "isFullUser": + if let value = try container.decode(Bool?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "name": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "picture": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "profile": + if let value = try container.decode(Objects.Profile?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "sharedArticles": + if let value = try container.decode([Objects.FeedArticle]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "sharedArticlesCount": + if let value = try container.decode(Int?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "sharedHighlightsCount": + if let value = try container.decode(Int?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "sharedNotesCount": + if let value = try container.decode(Int?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "viewerIsFollowing": + if let value = try container.decode(Bool?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + followersCount = map["followersCount"] + friendsCount = map["friendsCount"] + id = map["id"] + isFriend = map["isFriend"] + isFullUser = map["isFullUser"] + name = map["name"] + picture = map["picture"] + profile = map["profile"] + sharedArticles = map["sharedArticles"] + sharedArticlesCount = map["sharedArticlesCount"] + sharedHighlightsCount = map["sharedHighlightsCount"] + sharedNotesCount = map["sharedNotesCount"] + viewerIsFollowing = map["viewerIsFollowing"] + } +} + +extension Fields where TypeLock == Objects.User { + func id() throws -> String { + let field = GraphQLField.leaf( + name: "id", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.id[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func name() throws -> String { + let field = GraphQLField.leaf( + name: "name", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.name[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func isFullUser() throws -> Bool? { + let field = GraphQLField.leaf( + name: "isFullUser", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.isFullUser[field.alias!] + case .mocking: + return nil + } + } + + func viewerIsFollowing() throws -> Bool? { + let field = GraphQLField.leaf( + name: "viewerIsFollowing", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.viewerIsFollowing[field.alias!] + case .mocking: + return nil + } + } + + @available(*, deprecated, message: "isFriend has been replaced with viewerIsFollowing") + func isFriend() throws -> Bool? { + let field = GraphQLField.leaf( + name: "isFriend", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.isFriend[field.alias!] + case .mocking: + return nil + } + } + + func picture() throws -> String? { + let field = GraphQLField.leaf( + name: "picture", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.picture[field.alias!] + case .mocking: + return nil + } + } + + func profile(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "profile", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.profile[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func sharedArticles(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "sharedArticles", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.sharedArticles[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func sharedArticlesCount() throws -> Int? { + let field = GraphQLField.leaf( + name: "sharedArticlesCount", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.sharedArticlesCount[field.alias!] + case .mocking: + return nil + } + } + + func sharedHighlightsCount() throws -> Int? { + let field = GraphQLField.leaf( + name: "sharedHighlightsCount", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.sharedHighlightsCount[field.alias!] + case .mocking: + return nil + } + } + + func sharedNotesCount() throws -> Int? { + let field = GraphQLField.leaf( + name: "sharedNotesCount", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.sharedNotesCount[field.alias!] + case .mocking: + return nil + } + } + + func friendsCount() throws -> Int? { + let field = GraphQLField.leaf( + name: "friendsCount", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.friendsCount[field.alias!] + case .mocking: + return nil + } + } + + func followersCount() throws -> Int? { + let field = GraphQLField.leaf( + name: "followersCount", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.followersCount[field.alias!] + case .mocking: + return nil + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias User = Selection +} + +extension Objects { + struct Profile { + let __typename: TypeName = .profile + let bio: [String: String] + let id: [String: String] + let pictureUrl: [String: String] + let `private`: [String: Bool] + let username: [String: String] + + enum TypeName: String, Codable { + case profile = "Profile" + } + } +} + +extension Objects.Profile: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "bio": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "id": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "pictureUrl": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "private": + if let value = try container.decode(Bool?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "username": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + bio = map["bio"] + id = map["id"] + pictureUrl = map["pictureUrl"] + self.private = map["private"] + username = map["username"] + } +} + +extension Fields where TypeLock == Objects.Profile { + func id() throws -> String { + let field = GraphQLField.leaf( + name: "id", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.id[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func username() throws -> String { + let field = GraphQLField.leaf( + name: "username", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.username[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func `private`() throws -> Bool { + let field = GraphQLField.leaf( + name: "private", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.private[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Bool.mockValue + } + } + + func bio() throws -> String? { + let field = GraphQLField.leaf( + name: "bio", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.bio[field.alias!] + case .mocking: + return nil + } + } + + func pictureUrl() throws -> String? { + let field = GraphQLField.leaf( + name: "pictureUrl", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.pictureUrl[field.alias!] + case .mocking: + return nil + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias Profile = Selection +} + +extension Objects { + struct UserError { + let __typename: TypeName = .userError + let errorCodes: [String: [Enums.UserErrorCode]] + + enum TypeName: String, Codable { + case userError = "UserError" + } + } +} + +extension Objects.UserError: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -44,7 +951,7 @@ extension Objects.AddPopularReadError: Decodable { switch field { case "errorCodes": - if let value = try container.decode([Enums.AddPopularReadErrorCode]?.self, forKey: codingKey) { + if let value = try container.decode([Enums.UserErrorCode]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } default: @@ -61,8 +968,8 @@ extension Objects.AddPopularReadError: Decodable { } } -extension Fields where TypeLock == Objects.AddPopularReadError { - func errorCodes() throws -> [Enums.AddPopularReadErrorCode] { +extension Fields where TypeLock == Objects.UserError { + func errorCodes() throws -> [Enums.UserErrorCode] { let field = GraphQLField.leaf( name: "errorCodes", arguments: [] @@ -82,21 +989,21 @@ extension Fields where TypeLock == Objects.AddPopularReadError { } extension Selection where TypeLock == Never, Type == Never { - typealias AddPopularReadError = Selection + typealias UserError = Selection } extension Objects { - struct AddPopularReadSuccess { - let __typename: TypeName = .addPopularReadSuccess - let pageId: [String: String] + struct UserSuccess { + let __typename: TypeName = .userSuccess + let user: [String: Objects.User] enum TypeName: String, Codable { - case addPopularReadSuccess = "AddPopularReadSuccess" + case userSuccess = "UserSuccess" } } } -extension Objects.AddPopularReadSuccess: Decodable { +extension Objects.UserSuccess: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -108,8 +1015,8 @@ extension Objects.AddPopularReadSuccess: Decodable { let field = GraphQLField.getFieldNameFromAlias(alias) switch field { - case "pageId": - if let value = try container.decode(String?.self, forKey: codingKey) { + case "user": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } default: @@ -122,47 +1029,47 @@ extension Objects.AddPopularReadSuccess: Decodable { } } - pageId = map["pageId"] + user = map["user"] } } -extension Fields where TypeLock == Objects.AddPopularReadSuccess { - func pageId() throws -> String { - let field = GraphQLField.leaf( - name: "pageId", - arguments: [] +extension Fields where TypeLock == Objects.UserSuccess { + func user(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "user", + arguments: [], + selection: selection.selection ) select(field) switch response { case let .decoding(data): - if let data = data.pageId[field.alias!] { - return data + if let data = data.user[field.alias!] { + return try selection.decode(data: data) } throw HttpError.badpayload case .mocking: - return String.mockValue + return selection.mock() } } } extension Selection where TypeLock == Never, Type == Never { - typealias AddPopularReadSuccess = Selection + typealias UserSuccess = Selection } extension Objects { - struct ArchiveLinkError { - let __typename: TypeName = .archiveLinkError - let errorCodes: [String: [Enums.ArchiveLinkErrorCode]] - let message: [String: String] + struct UsersError { + let __typename: TypeName = .usersError + let errorCodes: [String: [Enums.UsersErrorCode]] enum TypeName: String, Codable { - case archiveLinkError = "ArchiveLinkError" + case usersError = "UsersError" } } } -extension Objects.ArchiveLinkError: Decodable { +extension Objects.UsersError: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -175,11 +1082,7 @@ extension Objects.ArchiveLinkError: Decodable { switch field { case "errorCodes": - if let value = try container.decode([Enums.ArchiveLinkErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "message": - if let value = try container.decode(String?.self, forKey: codingKey) { + if let value = try container.decode([Enums.UsersErrorCode]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } default: @@ -193,12 +1096,11 @@ extension Objects.ArchiveLinkError: Decodable { } errorCodes = map["errorCodes"] - message = map["message"] } } -extension Fields where TypeLock == Objects.ArchiveLinkError { - func errorCodes() throws -> [Enums.ArchiveLinkErrorCode] { +extension Fields where TypeLock == Objects.UsersError { + func errorCodes() throws -> [Enums.UsersErrorCode] { let field = GraphQLField.leaf( name: "errorCodes", arguments: [] @@ -215,43 +1117,24 @@ extension Fields where TypeLock == Objects.ArchiveLinkError { return [] } } - - func message() throws -> String { - let field = GraphQLField.leaf( - name: "message", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.message[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } } extension Selection where TypeLock == Never, Type == Never { - typealias ArchiveLinkError = Selection + typealias UsersError = Selection } extension Objects { - struct ArchiveLinkSuccess { - let __typename: TypeName = .archiveLinkSuccess - let linkId: [String: String] - let message: [String: String] + struct UsersSuccess { + let __typename: TypeName = .usersSuccess + let users: [String: [Objects.User]] enum TypeName: String, Codable { - case archiveLinkSuccess = "ArchiveLinkSuccess" + case usersSuccess = "UsersSuccess" } } } -extension Objects.ArchiveLinkSuccess: Decodable { +extension Objects.UsersSuccess: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -263,10 +1146,399 @@ extension Objects.ArchiveLinkSuccess: Decodable { let field = GraphQLField.getFieldNameFromAlias(alias) switch field { - case "linkId": - if let value = try container.decode(String?.self, forKey: codingKey) { + case "users": + if let value = try container.decode([Objects.User]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + users = map["users"] + } +} + +extension Fields where TypeLock == Objects.UsersSuccess { + func users(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "users", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.users[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UsersSuccess = Selection +} + +extension Objects { + struct LoginSuccess { + let __typename: TypeName = .loginSuccess + let me: [String: Objects.User] + + enum TypeName: String, Codable { + case loginSuccess = "LoginSuccess" + } + } +} + +extension Objects.LoginSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "me": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + me = map["me"] + } +} + +extension Fields where TypeLock == Objects.LoginSuccess { + func me(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "me", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.me[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias LoginSuccess = Selection +} + +extension Objects { + struct LoginError { + let __typename: TypeName = .loginError + let errorCodes: [String: [Enums.LoginErrorCode]] + + enum TypeName: String, Codable { + case loginError = "LoginError" + } + } +} + +extension Objects.LoginError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.LoginErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.LoginError { + func errorCodes() throws -> [Enums.LoginErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias LoginError = Selection +} + +extension Objects { + struct GoogleSignupSuccess { + let __typename: TypeName = .googleSignupSuccess + let me: [String: Objects.User] + + enum TypeName: String, Codable { + case googleSignupSuccess = "GoogleSignupSuccess" + } + } +} + +extension Objects.GoogleSignupSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "me": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + me = map["me"] + } +} + +extension Fields where TypeLock == Objects.GoogleSignupSuccess { + func me(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "me", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.me[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias GoogleSignupSuccess = Selection +} + +extension Objects { + struct GoogleSignupError { + let __typename: TypeName = .googleSignupError + let errorCodes: [String: [Enums.SignupErrorCode?]] + + enum TypeName: String, Codable { + case googleSignupError = "GoogleSignupError" + } + } +} + +extension Objects.GoogleSignupError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SignupErrorCode?]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.GoogleSignupError { + func errorCodes() throws -> [Enums.SignupErrorCode?] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias GoogleSignupError = Selection +} + +extension Objects { + struct LogOutError { + let __typename: TypeName = .logOutError + let errorCodes: [String: [Enums.LogOutErrorCode]] + + enum TypeName: String, Codable { + case logOutError = "LogOutError" + } + } +} + +extension Objects.LogOutError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.LogOutErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.LogOutError { + func errorCodes() throws -> [Enums.LogOutErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias LogOutError = Selection +} + +extension Objects { + struct LogOutSuccess { + let __typename: TypeName = .logOutSuccess + let message: [String: String] + + enum TypeName: String, Codable { + case logOutSuccess = "LogOutSuccess" + } + } +} + +extension Objects.LogOutSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { case "message": if let value = try container.decode(String?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) @@ -281,31 +1553,12 @@ extension Objects.ArchiveLinkSuccess: Decodable { } } - linkId = map["linkId"] message = map["message"] } } -extension Fields where TypeLock == Objects.ArchiveLinkSuccess { - func linkId() throws -> String { - let field = GraphQLField.leaf( - name: "linkId", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.linkId[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func message() throws -> String { +extension Fields where TypeLock == Objects.LogOutSuccess { + func message() throws -> String? { let field = GraphQLField.leaf( name: "message", arguments: [] @@ -314,7 +1567,688 @@ extension Fields where TypeLock == Objects.ArchiveLinkSuccess { switch response { case let .decoding(data): - if let data = data.message[field.alias!] { + return data.message[field.alias!] + case .mocking: + return nil + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias LogOutSuccess = Selection +} + +extension Objects { + struct UpdateUserError { + let __typename: TypeName = .updateUserError + let errorCodes: [String: [Enums.UpdateUserErrorCode]] + + enum TypeName: String, Codable { + case updateUserError = "UpdateUserError" + } + } +} + +extension Objects.UpdateUserError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdateUserErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.UpdateUserError { + func errorCodes() throws -> [Enums.UpdateUserErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateUserError = Selection +} + +extension Objects { + struct UpdateUserSuccess { + let __typename: TypeName = .updateUserSuccess + let user: [String: Objects.User] + + enum TypeName: String, Codable { + case updateUserSuccess = "UpdateUserSuccess" + } + } +} + +extension Objects.UpdateUserSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "user": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + user = map["user"] + } +} + +extension Fields where TypeLock == Objects.UpdateUserSuccess { + func user(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "user", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.user[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateUserSuccess = Selection +} + +extension Objects { + struct UpdateUserProfileSuccess { + let __typename: TypeName = .updateUserProfileSuccess + let user: [String: Objects.User] + + enum TypeName: String, Codable { + case updateUserProfileSuccess = "UpdateUserProfileSuccess" + } + } +} + +extension Objects.UpdateUserProfileSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "user": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + user = map["user"] + } +} + +extension Fields where TypeLock == Objects.UpdateUserProfileSuccess { + func user(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "user", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.user[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateUserProfileSuccess = Selection +} + +extension Objects { + struct UpdateUserProfileError { + let __typename: TypeName = .updateUserProfileError + let errorCodes: [String: [Enums.UpdateUserProfileErrorCode]] + + enum TypeName: String, Codable { + case updateUserProfileError = "UpdateUserProfileError" + } + } +} + +extension Objects.UpdateUserProfileError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdateUserProfileErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.UpdateUserProfileError { + func errorCodes() throws -> [Enums.UpdateUserProfileErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateUserProfileError = Selection +} + +extension Objects { + struct ReadState { + let __typename: TypeName = .readState + let progressAnchorIndex: [String: Int] + let progressPercent: [String: Double] + let reading: [String: Bool] + let readingTime: [String: Int] + + enum TypeName: String, Codable { + case readState = "ReadState" + } + } +} + +extension Objects.ReadState: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "progressAnchorIndex": + if let value = try container.decode(Int?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "progressPercent": + if let value = try container.decode(Double?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "reading": + if let value = try container.decode(Bool?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "readingTime": + if let value = try container.decode(Int?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + progressAnchorIndex = map["progressAnchorIndex"] + progressPercent = map["progressPercent"] + reading = map["reading"] + readingTime = map["readingTime"] + } +} + +extension Fields where TypeLock == Objects.ReadState { + func reading() throws -> Bool? { + let field = GraphQLField.leaf( + name: "reading", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.reading[field.alias!] + case .mocking: + return nil + } + } + + func readingTime() throws -> Int? { + let field = GraphQLField.leaf( + name: "readingTime", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.readingTime[field.alias!] + case .mocking: + return nil + } + } + + func progressPercent() throws -> Double { + let field = GraphQLField.leaf( + name: "progressPercent", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.progressPercent[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Double.mockValue + } + } + + func progressAnchorIndex() throws -> Int { + let field = GraphQLField.leaf( + name: "progressAnchorIndex", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.progressAnchorIndex[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Int.mockValue + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ReadState = Selection +} + +extension Objects { + struct HighlightStats { + let __typename: TypeName = .highlightStats + let highlightCount: [String: Int] + + enum TypeName: String, Codable { + case highlightStats = "HighlightStats" + } + } +} + +extension Objects.HighlightStats: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "highlightCount": + if let value = try container.decode(Int?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + highlightCount = map["highlightCount"] + } +} + +extension Fields where TypeLock == Objects.HighlightStats { + func highlightCount() throws -> Int { + let field = GraphQLField.leaf( + name: "highlightCount", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.highlightCount[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Int.mockValue + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias HighlightStats = Selection +} + +extension Objects { + struct ShareStats { + let __typename: TypeName = .shareStats + let readDuration: [String: Int] + let saveCount: [String: Int] + let viewCount: [String: Int] + + enum TypeName: String, Codable { + case shareStats = "ShareStats" + } + } +} + +extension Objects.ShareStats: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "readDuration": + if let value = try container.decode(Int?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "saveCount": + if let value = try container.decode(Int?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "viewCount": + if let value = try container.decode(Int?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + readDuration = map["readDuration"] + saveCount = map["saveCount"] + viewCount = map["viewCount"] + } +} + +extension Fields where TypeLock == Objects.ShareStats { + func viewCount() throws -> Int { + let field = GraphQLField.leaf( + name: "viewCount", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.viewCount[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Int.mockValue + } + } + + func saveCount() throws -> Int { + let field = GraphQLField.leaf( + name: "saveCount", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.saveCount[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Int.mockValue + } + } + + func readDuration() throws -> Int { + let field = GraphQLField.leaf( + name: "readDuration", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.readDuration[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Int.mockValue + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ShareStats = Selection +} + +extension Objects { + struct LinkShareInfo { + let __typename: TypeName = .linkShareInfo + let description: [String: String] + let imageUrl: [String: String] + let title: [String: String] + + enum TypeName: String, Codable { + case linkShareInfo = "LinkShareInfo" + } + } +} + +extension Objects.LinkShareInfo: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "description": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "imageUrl": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "title": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + description = map["description"] + imageUrl = map["imageUrl"] + title = map["title"] + } +} + +extension Fields where TypeLock == Objects.LinkShareInfo { + func title() throws -> String { + let field = GraphQLField.leaf( + name: "title", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.title[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func description() throws -> String { + let field = GraphQLField.leaf( + name: "description", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.description[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func imageUrl() throws -> String { + let field = GraphQLField.leaf( + name: "imageUrl", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.imageUrl[field.alias!] { return data } throw HttpError.badpayload @@ -325,7 +2259,692 @@ extension Fields where TypeLock == Objects.ArchiveLinkSuccess { } extension Selection where TypeLock == Never, Type == Never { - typealias ArchiveLinkSuccess = Selection + typealias LinkShareInfo = Selection +} + +extension Objects { + struct Link { + let __typename: TypeName = .link + let highlightStats: [String: Objects.HighlightStats] + let id: [String: String] + let page: [String: Objects.Page] + let postedByViewer: [String: Bool] + let readState: [String: Objects.ReadState] + let savedAt: [String: DateTime] + let savedBy: [String: Objects.User] + let savedByViewer: [String: Bool] + let shareInfo: [String: Objects.LinkShareInfo] + let shareStats: [String: Objects.ShareStats] + let slug: [String: String] + let url: [String: String] + + enum TypeName: String, Codable { + case link = "Link" + } + } +} + +extension Objects.Link: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "highlightStats": + if let value = try container.decode(Objects.HighlightStats?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "id": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "page": + if let value = try container.decode(Objects.Page?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "postedByViewer": + if let value = try container.decode(Bool?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "readState": + if let value = try container.decode(Objects.ReadState?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "savedAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "savedBy": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "savedByViewer": + if let value = try container.decode(Bool?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "shareInfo": + if let value = try container.decode(Objects.LinkShareInfo?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "shareStats": + if let value = try container.decode(Objects.ShareStats?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "slug": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "url": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + highlightStats = map["highlightStats"] + id = map["id"] + page = map["page"] + postedByViewer = map["postedByViewer"] + readState = map["readState"] + savedAt = map["savedAt"] + savedBy = map["savedBy"] + savedByViewer = map["savedByViewer"] + shareInfo = map["shareInfo"] + shareStats = map["shareStats"] + slug = map["slug"] + url = map["url"] + } +} + +extension Fields where TypeLock == Objects.Link { + func id() throws -> String { + let field = GraphQLField.leaf( + name: "id", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.id[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func url() throws -> String { + let field = GraphQLField.leaf( + name: "url", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.url[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func slug() throws -> String { + let field = GraphQLField.leaf( + name: "slug", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.slug[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func savedBy(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "savedBy", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.savedBy[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func savedAt() throws -> DateTime { + let field = GraphQLField.leaf( + name: "savedAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.savedAt[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return DateTime.mockValue + } + } + + func savedByViewer() throws -> Bool { + let field = GraphQLField.leaf( + name: "savedByViewer", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.savedByViewer[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Bool.mockValue + } + } + + func postedByViewer() throws -> Bool { + let field = GraphQLField.leaf( + name: "postedByViewer", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.postedByViewer[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Bool.mockValue + } + } + + func readState(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "readState", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.readState[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func highlightStats(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "highlightStats", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.highlightStats[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func shareInfo(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "shareInfo", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.shareInfo[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func shareStats(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "shareStats", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.shareStats[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func page(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "page", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.page[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias Link = Selection +} + +extension Objects { + struct Page { + let __typename: TypeName = .page + let author: [String: String] + let createdAt: [String: DateTime] + let description: [String: String] + let hash: [String: String] + let id: [String: String] + let image: [String: String] + let originalHtml: [String: String] + let originalUrl: [String: String] + let publishedAt: [String: DateTime] + let readableHtml: [String: String] + let title: [String: String] + let type: [String: Enums.PageType] + let url: [String: String] + + enum TypeName: String, Codable { + case page = "Page" + } + } +} + +extension Objects.Page: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "author": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "createdAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "description": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "hash": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "id": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "image": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "originalHtml": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "originalUrl": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "publishedAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "readableHtml": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "title": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "type": + if let value = try container.decode(Enums.PageType?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "url": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + author = map["author"] + createdAt = map["createdAt"] + description = map["description"] + hash = map["hash"] + id = map["id"] + image = map["image"] + originalHtml = map["originalHtml"] + originalUrl = map["originalUrl"] + publishedAt = map["publishedAt"] + readableHtml = map["readableHtml"] + title = map["title"] + type = map["type"] + url = map["url"] + } +} + +extension Fields where TypeLock == Objects.Page { + func id() throws -> String { + let field = GraphQLField.leaf( + name: "id", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.id[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func url() throws -> String { + let field = GraphQLField.leaf( + name: "url", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.url[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func hash() throws -> String { + let field = GraphQLField.leaf( + name: "hash", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.hash[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func originalUrl() throws -> String { + let field = GraphQLField.leaf( + name: "originalUrl", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.originalUrl[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func type() throws -> Enums.PageType { + let field = GraphQLField.leaf( + name: "type", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.type[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Enums.PageType.allCases.first! + } + } + + func image() throws -> String { + let field = GraphQLField.leaf( + name: "image", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.image[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func title() throws -> String { + let field = GraphQLField.leaf( + name: "title", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.title[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func author() throws -> String { + let field = GraphQLField.leaf( + name: "author", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.author[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func description() throws -> String { + let field = GraphQLField.leaf( + name: "description", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.description[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func publishedAt() throws -> DateTime? { + let field = GraphQLField.leaf( + name: "publishedAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.publishedAt[field.alias!] + case .mocking: + return nil + } + } + + func originalHtml() throws -> String { + let field = GraphQLField.leaf( + name: "originalHtml", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.originalHtml[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func readableHtml() throws -> String { + let field = GraphQLField.leaf( + name: "readableHtml", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.readableHtml[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func createdAt() throws -> DateTime { + let field = GraphQLField.leaf( + name: "createdAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.createdAt[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return DateTime.mockValue + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias Page = Selection } extension Objects { @@ -343,6 +2962,7 @@ extension Objects { let image: [String: String] let isArchived: [String: Bool] let labels: [String: [Objects.Label]] + let language: [String: String] let linkId: [String: String] let originalArticleUrl: [String: String] let originalHtml: [String: String] @@ -432,6 +3052,10 @@ extension Objects.Article: Decodable { if let value = try container.decode([Objects.Label]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } + case "language": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } case "linkId": if let value = try container.decode(String?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) @@ -542,6 +3166,7 @@ extension Objects.Article: Decodable { image = map["image"] isArchived = map["isArchived"] labels = map["labels"] + language = map["language"] linkId = map["linkId"] originalArticleUrl = map["originalArticleUrl"] originalHtml = map["originalHtml"] @@ -568,18 +3193,93 @@ extension Objects.Article: Decodable { } extension Fields where TypeLock == Objects.Article { - func author() throws -> String? { + func id() throws -> String { let field = GraphQLField.leaf( - name: "author", + name: "id", arguments: [] ) select(field) switch response { case let .decoding(data): - return data.author[field.alias!] + if let data = data.id[field.alias!] { + return data + } + throw HttpError.badpayload case .mocking: - return nil + return String.mockValue + } + } + + func title() throws -> String { + let field = GraphQLField.leaf( + name: "title", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.title[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func slug() throws -> String { + let field = GraphQLField.leaf( + name: "slug", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.slug[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func url() throws -> String { + let field = GraphQLField.leaf( + name: "url", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.url[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func hash() throws -> String { + let field = GraphQLField.leaf( + name: "hash", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.hash[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue } } @@ -601,6 +3301,21 @@ extension Fields where TypeLock == Objects.Article { } } + func pageType() throws -> Enums.PageType? { + let field = GraphQLField.leaf( + name: "pageType", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.pageType[field.alias!] + case .mocking: + return nil + } + } + func contentReader() throws -> Enums.ContentReader { let field = GraphQLField.leaf( name: "contentReader", @@ -619,6 +3334,81 @@ extension Fields where TypeLock == Objects.Article { } } + func hasContent() throws -> Bool? { + let field = GraphQLField.leaf( + name: "hasContent", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.hasContent[field.alias!] + case .mocking: + return nil + } + } + + func author() throws -> String? { + let field = GraphQLField.leaf( + name: "author", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.author[field.alias!] + case .mocking: + return nil + } + } + + func image() throws -> String? { + let field = GraphQLField.leaf( + name: "image", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.image[field.alias!] + case .mocking: + return nil + } + } + + func description() throws -> String? { + let field = GraphQLField.leaf( + name: "description", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.description[field.alias!] + case .mocking: + return nil + } + } + + func originalHtml() throws -> String? { + let field = GraphQLField.leaf( + name: "originalHtml", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.originalHtml[field.alias!] + case .mocking: + return nil + } + } + func createdAt() throws -> DateTime { let field = GraphQLField.leaf( name: "createdAt", @@ -637,51 +3427,132 @@ extension Fields where TypeLock == Objects.Article { } } - func description() throws -> String? { + func savedAt() throws -> DateTime { let field = GraphQLField.leaf( - name: "description", + name: "savedAt", arguments: [] ) select(field) switch response { case let .decoding(data): - return data.description[field.alias!] - case .mocking: - return nil - } - } - - func hasContent() throws -> Bool? { - let field = GraphQLField.leaf( - name: "hasContent", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.hasContent[field.alias!] - case .mocking: - return nil - } - } - - func hash() throws -> String { - let field = GraphQLField.leaf( - name: "hash", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.hash[field.alias!] { + if let data = data.savedAt[field.alias!] { return data } throw HttpError.badpayload case .mocking: - return String.mockValue + return DateTime.mockValue + } + } + + func publishedAt() throws -> DateTime? { + let field = GraphQLField.leaf( + name: "publishedAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.publishedAt[field.alias!] + case .mocking: + return nil + } + } + + func readingProgressPercent() throws -> Double { + let field = GraphQLField.leaf( + name: "readingProgressPercent", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.readingProgressPercent[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Double.mockValue + } + } + + func readingProgressAnchorIndex() throws -> Int { + let field = GraphQLField.leaf( + name: "readingProgressAnchorIndex", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.readingProgressAnchorIndex[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Int.mockValue + } + } + + func sharedComment() throws -> String? { + let field = GraphQLField.leaf( + name: "sharedComment", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.sharedComment[field.alias!] + case .mocking: + return nil + } + } + + func savedByViewer() throws -> Bool? { + let field = GraphQLField.leaf( + name: "savedByViewer", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.savedByViewer[field.alias!] + case .mocking: + return nil + } + } + + func postedByViewer() throws -> Bool? { + let field = GraphQLField.leaf( + name: "postedByViewer", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.postedByViewer[field.alias!] + case .mocking: + return nil + } + } + + func originalArticleUrl() throws -> String? { + let field = GraphQLField.leaf( + name: "originalArticleUrl", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.originalArticleUrl[field.alias!] + case .mocking: + return nil } } @@ -704,36 +3575,19 @@ extension Fields where TypeLock == Objects.Article { } } - func id() throws -> String { - let field = GraphQLField.leaf( - name: "id", - arguments: [] + func shareInfo(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "shareInfo", + arguments: [], + selection: selection.selection ) select(field) switch response { case let .decoding(data): - if let data = data.id[field.alias!] { - return data - } - throw HttpError.badpayload + return try selection.decode(data: data.shareInfo[field.alias!]) case .mocking: - return String.mockValue - } - } - - func image() throws -> String? { - let field = GraphQLField.leaf( - name: "image", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.image[field.alias!] - case .mocking: - return nil + return selection.mock() } } @@ -755,6 +3609,21 @@ extension Fields where TypeLock == Objects.Article { } } + func linkId() throws -> String? { + let field = GraphQLField.leaf( + name: "linkId", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.linkId[field.alias!] + case .mocking: + return nil + } + } + func labels(selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "labels", @@ -771,206 +3640,16 @@ extension Fields where TypeLock == Objects.Article { } } - func linkId() throws -> String? { + func uploadFileId() throws -> String? { let field = GraphQLField.leaf( - name: "linkId", + name: "uploadFileId", arguments: [] ) select(field) switch response { case let .decoding(data): - return data.linkId[field.alias!] - case .mocking: - return nil - } - } - - func originalArticleUrl() throws -> String? { - let field = GraphQLField.leaf( - name: "originalArticleUrl", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.originalArticleUrl[field.alias!] - case .mocking: - return nil - } - } - - func originalHtml() throws -> String? { - let field = GraphQLField.leaf( - name: "originalHtml", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.originalHtml[field.alias!] - case .mocking: - return nil - } - } - - func pageType() throws -> Enums.PageType? { - let field = GraphQLField.leaf( - name: "pageType", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.pageType[field.alias!] - case .mocking: - return nil - } - } - - func postedByViewer() throws -> Bool? { - let field = GraphQLField.leaf( - name: "postedByViewer", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.postedByViewer[field.alias!] - case .mocking: - return nil - } - } - - func publishedAt() throws -> DateTime? { - let field = GraphQLField.leaf( - name: "publishedAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.publishedAt[field.alias!] - case .mocking: - return nil - } - } - - func readingProgressAnchorIndex() throws -> Int { - let field = GraphQLField.leaf( - name: "readingProgressAnchorIndex", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.readingProgressAnchorIndex[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Int.mockValue - } - } - - func readingProgressPercent() throws -> Double { - let field = GraphQLField.leaf( - name: "readingProgressPercent", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.readingProgressPercent[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Double.mockValue - } - } - - func savedAt() throws -> DateTime { - let field = GraphQLField.leaf( - name: "savedAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.savedAt[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return DateTime.mockValue - } - } - - func savedByViewer() throws -> Bool? { - let field = GraphQLField.leaf( - name: "savedByViewer", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.savedByViewer[field.alias!] - case .mocking: - return nil - } - } - - func sharedComment() throws -> String? { - let field = GraphQLField.leaf( - name: "sharedComment", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.sharedComment[field.alias!] - case .mocking: - return nil - } - } - - func shareInfo(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "shareInfo", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - return try selection.decode(data: data.shareInfo[field.alias!]) - case .mocking: - return selection.mock() - } - } - - func siteIcon() throws -> String? { - let field = GraphQLField.leaf( - name: "siteIcon", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.siteIcon[field.alias!] + return data.uploadFileId[field.alias!] case .mocking: return nil } @@ -991,34 +3670,16 @@ extension Fields where TypeLock == Objects.Article { } } - func slug() throws -> String { + func siteIcon() throws -> String? { let field = GraphQLField.leaf( - name: "slug", + name: "siteIcon", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.slug[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func state() throws -> Enums.ArticleSavingRequestStatus? { - let field = GraphQLField.leaf( - name: "state", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.state[field.alias!] + return data.siteIcon[field.alias!] case .mocking: return nil } @@ -1039,21 +3700,18 @@ extension Fields where TypeLock == Objects.Article { } } - func title() throws -> String { + func unsubMailTo() throws -> String? { let field = GraphQLField.leaf( - name: "title", + name: "unsubMailTo", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.title[field.alias!] { - return data - } - throw HttpError.badpayload + return data.unsubMailTo[field.alias!] case .mocking: - return String.mockValue + return nil } } @@ -1072,149 +3730,41 @@ extension Fields where TypeLock == Objects.Article { } } - func unsubMailTo() throws -> String? { + func state() throws -> Enums.ArticleSavingRequestStatus? { let field = GraphQLField.leaf( - name: "unsubMailTo", + name: "state", arguments: [] ) select(field) switch response { case let .decoding(data): - return data.unsubMailTo[field.alias!] + return data.state[field.alias!] case .mocking: return nil } } - func uploadFileId() throws -> String? { + func language() throws -> String? { let field = GraphQLField.leaf( - name: "uploadFileId", + name: "language", arguments: [] ) select(field) switch response { case let .decoding(data): - return data.uploadFileId[field.alias!] + return data.language[field.alias!] case .mocking: return nil } } - - func url() throws -> String { - let field = GraphQLField.leaf( - name: "url", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.url[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } } extension Selection where TypeLock == Never, Type == Never { typealias Article = Selection } -extension Objects { - struct ArticleEdge { - let __typename: TypeName = .articleEdge - let cursor: [String: String] - let node: [String: Objects.Article] - - enum TypeName: String, Codable { - case articleEdge = "ArticleEdge" - } - } -} - -extension Objects.ArticleEdge: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "cursor": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "node": - if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - cursor = map["cursor"] - node = map["node"] - } -} - -extension Fields where TypeLock == Objects.ArticleEdge { - func cursor() throws -> String { - let field = GraphQLField.leaf( - name: "cursor", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.cursor[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func node(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "node", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.node[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias ArticleEdge = Selection -} - extension Objects { struct ArticleError { let __typename: TypeName = .articleError @@ -1280,548 +3830,6 @@ extension Selection where TypeLock == Never, Type == Never { typealias ArticleError = Selection } -extension Objects { - struct ArticleSavingRequest { - let __typename: TypeName = .articleSavingRequest - let article: [String: Objects.Article] - let createdAt: [String: DateTime] - let errorCode: [String: Enums.CreateArticleErrorCode] - let id: [String: String] - let slug: [String: String] - let status: [String: Enums.ArticleSavingRequestStatus] - let updatedAt: [String: DateTime] - let user: [String: Objects.User] - let userId: [String: String] - - enum TypeName: String, Codable { - case articleSavingRequest = "ArticleSavingRequest" - } - } -} - -extension Objects.ArticleSavingRequest: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "article": - if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "createdAt": - if let value = try container.decode(DateTime?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "errorCode": - if let value = try container.decode(Enums.CreateArticleErrorCode?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "id": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "slug": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "status": - if let value = try container.decode(Enums.ArticleSavingRequestStatus?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "updatedAt": - if let value = try container.decode(DateTime?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "user": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "userId": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - article = map["article"] - createdAt = map["createdAt"] - errorCode = map["errorCode"] - id = map["id"] - slug = map["slug"] - status = map["status"] - updatedAt = map["updatedAt"] - user = map["user"] - userId = map["userId"] - } -} - -extension Fields where TypeLock == Objects.ArticleSavingRequest { - @available(*, deprecated, message: "article has been replaced with slug") - func article(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "article", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - return try selection.decode(data: data.article[field.alias!]) - case .mocking: - return selection.mock() - } - } - - func createdAt() throws -> DateTime { - let field = GraphQLField.leaf( - name: "createdAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.createdAt[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return DateTime.mockValue - } - } - - func errorCode() throws -> Enums.CreateArticleErrorCode? { - let field = GraphQLField.leaf( - name: "errorCode", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.errorCode[field.alias!] - case .mocking: - return nil - } - } - - func id() throws -> String { - let field = GraphQLField.leaf( - name: "id", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.id[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func slug() throws -> String { - let field = GraphQLField.leaf( - name: "slug", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.slug[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func status() throws -> Enums.ArticleSavingRequestStatus { - let field = GraphQLField.leaf( - name: "status", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.status[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Enums.ArticleSavingRequestStatus.allCases.first! - } - } - - func updatedAt() throws -> DateTime { - let field = GraphQLField.leaf( - name: "updatedAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.updatedAt[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return DateTime.mockValue - } - } - - func user(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "user", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.user[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - @available(*, deprecated, message: "userId has been replaced with user") - func userId() throws -> String { - let field = GraphQLField.leaf( - name: "userId", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.userId[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias ArticleSavingRequest = Selection -} - -extension Objects { - struct ArticleSavingRequestError { - let __typename: TypeName = .articleSavingRequestError - let errorCodes: [String: [Enums.ArticleSavingRequestErrorCode]] - - enum TypeName: String, Codable { - case articleSavingRequestError = "ArticleSavingRequestError" - } - } -} - -extension Objects.ArticleSavingRequestError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.ArticleSavingRequestErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.ArticleSavingRequestError { - func errorCodes() throws -> [Enums.ArticleSavingRequestErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias ArticleSavingRequestError = Selection -} - -extension Objects { - struct ArticleSavingRequestSuccess { - let __typename: TypeName = .articleSavingRequestSuccess - let articleSavingRequest: [String: Objects.ArticleSavingRequest] - - enum TypeName: String, Codable { - case articleSavingRequestSuccess = "ArticleSavingRequestSuccess" - } - } -} - -extension Objects.ArticleSavingRequestSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "articleSavingRequest": - if let value = try container.decode(Objects.ArticleSavingRequest?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - articleSavingRequest = map["articleSavingRequest"] - } -} - -extension Fields where TypeLock == Objects.ArticleSavingRequestSuccess { - func articleSavingRequest(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "articleSavingRequest", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.articleSavingRequest[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias ArticleSavingRequestSuccess = Selection -} - -extension Objects { - struct ArticlesError { - let __typename: TypeName = .articlesError - let errorCodes: [String: [Enums.ArticlesErrorCode]] - - enum TypeName: String, Codable { - case articlesError = "ArticlesError" - } - } -} - -extension Objects.ArticlesError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.ArticlesErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.ArticlesError { - func errorCodes() throws -> [Enums.ArticlesErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias ArticlesError = Selection -} - -extension Objects { - struct ArticlesSuccess { - let __typename: TypeName = .articlesSuccess - let edges: [String: [Objects.ArticleEdge]] - let pageInfo: [String: Objects.PageInfo] - - enum TypeName: String, Codable { - case articlesSuccess = "ArticlesSuccess" - } - } -} - -extension Objects.ArticlesSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "edges": - if let value = try container.decode([Objects.ArticleEdge]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "pageInfo": - if let value = try container.decode(Objects.PageInfo?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - edges = map["edges"] - pageInfo = map["pageInfo"] - } -} - -extension Fields where TypeLock == Objects.ArticlesSuccess { - func edges(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "edges", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.edges[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func pageInfo(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "pageInfo", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.pageInfo[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias ArticlesSuccess = Selection -} - extension Objects { struct ArticleSuccess { let __typename: TypeName = .articleSuccess @@ -1888,6 +3896,374 @@ extension Selection where TypeLock == Never, Type == Never { typealias ArticleSuccess = Selection } +extension Objects { + struct SharedArticleError { + let __typename: TypeName = .sharedArticleError + let errorCodes: [String: [Enums.SharedArticleErrorCode]] + + enum TypeName: String, Codable { + case sharedArticleError = "SharedArticleError" + } + } +} + +extension Objects.SharedArticleError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SharedArticleErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.SharedArticleError { + func errorCodes() throws -> [Enums.SharedArticleErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SharedArticleError = Selection +} + +extension Objects { + struct SharedArticleSuccess { + let __typename: TypeName = .sharedArticleSuccess + let article: [String: Objects.Article] + + enum TypeName: String, Codable { + case sharedArticleSuccess = "SharedArticleSuccess" + } + } +} + +extension Objects.SharedArticleSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "article": + if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + article = map["article"] + } +} + +extension Fields where TypeLock == Objects.SharedArticleSuccess { + func article(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "article", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.article[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SharedArticleSuccess = Selection +} + +extension Objects { + struct ArticlesError { + let __typename: TypeName = .articlesError + let errorCodes: [String: [Enums.ArticlesErrorCode]] + + enum TypeName: String, Codable { + case articlesError = "ArticlesError" + } + } +} + +extension Objects.ArticlesError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.ArticlesErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.ArticlesError { + func errorCodes() throws -> [Enums.ArticlesErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ArticlesError = Selection +} + +extension Objects { + struct UploadFileRequestError { + let __typename: TypeName = .uploadFileRequestError + let errorCodes: [String: [Enums.UploadFileRequestErrorCode]] + + enum TypeName: String, Codable { + case uploadFileRequestError = "UploadFileRequestError" + } + } +} + +extension Objects.UploadFileRequestError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UploadFileRequestErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.UploadFileRequestError { + func errorCodes() throws -> [Enums.UploadFileRequestErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UploadFileRequestError = Selection +} + +extension Objects { + struct UploadFileRequestSuccess { + let __typename: TypeName = .uploadFileRequestSuccess + let id: [String: String] + let uploadFileId: [String: String] + let uploadSignedUrl: [String: String] + + enum TypeName: String, Codable { + case uploadFileRequestSuccess = "UploadFileRequestSuccess" + } + } +} + +extension Objects.UploadFileRequestSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "id": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "uploadFileId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "uploadSignedUrl": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + id = map["id"] + uploadFileId = map["uploadFileId"] + uploadSignedUrl = map["uploadSignedUrl"] + } +} + +extension Fields where TypeLock == Objects.UploadFileRequestSuccess { + func id() throws -> String { + let field = GraphQLField.leaf( + name: "id", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.id[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func uploadSignedUrl() throws -> String? { + let field = GraphQLField.leaf( + name: "uploadSignedUrl", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.uploadSignedUrl[field.alias!] + case .mocking: + return nil + } + } + + func uploadFileId() throws -> String? { + let field = GraphQLField.leaf( + name: "uploadFileId", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.uploadFileId[field.alias!] + case .mocking: + return nil + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UploadFileRequestSuccess = Selection +} + extension Objects { struct CreateArticleError { let __typename: TypeName = .createArticleError @@ -1953,137 +4329,6 @@ extension Selection where TypeLock == Never, Type == Never { typealias CreateArticleError = Selection } -extension Objects { - struct CreateArticleSavingRequestError { - let __typename: TypeName = .createArticleSavingRequestError - let errorCodes: [String: [Enums.CreateArticleSavingRequestErrorCode]] - - enum TypeName: String, Codable { - case createArticleSavingRequestError = "CreateArticleSavingRequestError" - } - } -} - -extension Objects.CreateArticleSavingRequestError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.CreateArticleSavingRequestErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.CreateArticleSavingRequestError { - func errorCodes() throws -> [Enums.CreateArticleSavingRequestErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateArticleSavingRequestError = Selection -} - -extension Objects { - struct CreateArticleSavingRequestSuccess { - let __typename: TypeName = .createArticleSavingRequestSuccess - let articleSavingRequest: [String: Objects.ArticleSavingRequest] - - enum TypeName: String, Codable { - case createArticleSavingRequestSuccess = "CreateArticleSavingRequestSuccess" - } - } -} - -extension Objects.CreateArticleSavingRequestSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "articleSavingRequest": - if let value = try container.decode(Objects.ArticleSavingRequest?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - articleSavingRequest = map["articleSavingRequest"] - } -} - -extension Fields where TypeLock == Objects.CreateArticleSavingRequestSuccess { - func articleSavingRequest(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "articleSavingRequest", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.articleSavingRequest[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateArticleSavingRequestSuccess = Selection -} - extension Objects { struct CreateArticleSuccess { let __typename: TypeName = .createArticleSuccess @@ -2138,24 +4383,6 @@ extension Objects.CreateArticleSuccess: Decodable { } extension Fields where TypeLock == Objects.CreateArticleSuccess { - func created() throws -> Bool { - let field = GraphQLField.leaf( - name: "created", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.created[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Bool.mockValue - } - } - func createdArticle(selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "createdArticle", @@ -2193,6 +4420,24 @@ extension Fields where TypeLock == Objects.CreateArticleSuccess { return selection.mock() } } + + func created() throws -> Bool { + let field = GraphQLField.leaf( + name: "created", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.created[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Bool.mockValue + } + } } extension Selection where TypeLock == Never, Type == Never { @@ -2200,17 +4445,18 @@ extension Selection where TypeLock == Never, Type == Never { } extension Objects { - struct CreateHighlightError { - let __typename: TypeName = .createHighlightError - let errorCodes: [String: [Enums.CreateHighlightErrorCode]] + struct SaveError { + let __typename: TypeName = .saveError + let errorCodes: [String: [Enums.SaveErrorCode]] + let message: [String: String] enum TypeName: String, Codable { - case createHighlightError = "CreateHighlightError" + case saveError = "SaveError" } } } -extension Objects.CreateHighlightError: Decodable { +extension Objects.SaveError: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -2223,1588 +4469,10 @@ extension Objects.CreateHighlightError: Decodable { switch field { case "errorCodes": - if let value = try container.decode([Enums.CreateHighlightErrorCode]?.self, forKey: codingKey) { + if let value = try container.decode([Enums.SaveErrorCode]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.CreateHighlightError { - func errorCodes() throws -> [Enums.CreateHighlightErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateHighlightError = Selection -} - -extension Objects { - struct CreateHighlightReplyError { - let __typename: TypeName = .createHighlightReplyError - let errorCodes: [String: [Enums.CreateHighlightReplyErrorCode]] - - enum TypeName: String, Codable { - case createHighlightReplyError = "CreateHighlightReplyError" - } - } -} - -extension Objects.CreateHighlightReplyError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.CreateHighlightReplyErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.CreateHighlightReplyError { - func errorCodes() throws -> [Enums.CreateHighlightReplyErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateHighlightReplyError = Selection -} - -extension Objects { - struct CreateHighlightReplySuccess { - let __typename: TypeName = .createHighlightReplySuccess - let highlightReply: [String: Objects.HighlightReply] - - enum TypeName: String, Codable { - case createHighlightReplySuccess = "CreateHighlightReplySuccess" - } - } -} - -extension Objects.CreateHighlightReplySuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "highlightReply": - if let value = try container.decode(Objects.HighlightReply?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - highlightReply = map["highlightReply"] - } -} - -extension Fields where TypeLock == Objects.CreateHighlightReplySuccess { - func highlightReply(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "highlightReply", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.highlightReply[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateHighlightReplySuccess = Selection -} - -extension Objects { - struct CreateHighlightSuccess { - let __typename: TypeName = .createHighlightSuccess - let highlight: [String: Objects.Highlight] - - enum TypeName: String, Codable { - case createHighlightSuccess = "CreateHighlightSuccess" - } - } -} - -extension Objects.CreateHighlightSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "highlight": - if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - highlight = map["highlight"] - } -} - -extension Fields where TypeLock == Objects.CreateHighlightSuccess { - func highlight(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "highlight", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.highlight[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateHighlightSuccess = Selection -} - -extension Objects { - struct CreateLabelError { - let __typename: TypeName = .createLabelError - let errorCodes: [String: [Enums.CreateLabelErrorCode]] - - enum TypeName: String, Codable { - case createLabelError = "CreateLabelError" - } - } -} - -extension Objects.CreateLabelError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.CreateLabelErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.CreateLabelError { - func errorCodes() throws -> [Enums.CreateLabelErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateLabelError = Selection -} - -extension Objects { - struct CreateLabelSuccess { - let __typename: TypeName = .createLabelSuccess - let label: [String: Objects.Label] - - enum TypeName: String, Codable { - case createLabelSuccess = "CreateLabelSuccess" - } - } -} - -extension Objects.CreateLabelSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "label": - if let value = try container.decode(Objects.Label?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - label = map["label"] - } -} - -extension Fields where TypeLock == Objects.CreateLabelSuccess { - func label(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "label", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.label[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateLabelSuccess = Selection -} - -extension Objects { - struct CreateNewsletterEmailError { - let __typename: TypeName = .createNewsletterEmailError - let errorCodes: [String: [Enums.CreateNewsletterEmailErrorCode]] - - enum TypeName: String, Codable { - case createNewsletterEmailError = "CreateNewsletterEmailError" - } - } -} - -extension Objects.CreateNewsletterEmailError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.CreateNewsletterEmailErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.CreateNewsletterEmailError { - func errorCodes() throws -> [Enums.CreateNewsletterEmailErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateNewsletterEmailError = Selection -} - -extension Objects { - struct CreateNewsletterEmailSuccess { - let __typename: TypeName = .createNewsletterEmailSuccess - let newsletterEmail: [String: Objects.NewsletterEmail] - - enum TypeName: String, Codable { - case createNewsletterEmailSuccess = "CreateNewsletterEmailSuccess" - } - } -} - -extension Objects.CreateNewsletterEmailSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "newsletterEmail": - if let value = try container.decode(Objects.NewsletterEmail?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - newsletterEmail = map["newsletterEmail"] - } -} - -extension Fields where TypeLock == Objects.CreateNewsletterEmailSuccess { - func newsletterEmail(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "newsletterEmail", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.newsletterEmail[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateNewsletterEmailSuccess = Selection -} - -extension Objects { - struct CreateReactionError { - let __typename: TypeName = .createReactionError - let errorCodes: [String: [Enums.CreateReactionErrorCode]] - - enum TypeName: String, Codable { - case createReactionError = "CreateReactionError" - } - } -} - -extension Objects.CreateReactionError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.CreateReactionErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.CreateReactionError { - func errorCodes() throws -> [Enums.CreateReactionErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateReactionError = Selection -} - -extension Objects { - struct CreateReactionSuccess { - let __typename: TypeName = .createReactionSuccess - let reaction: [String: Objects.Reaction] - - enum TypeName: String, Codable { - case createReactionSuccess = "CreateReactionSuccess" - } - } -} - -extension Objects.CreateReactionSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "reaction": - if let value = try container.decode(Objects.Reaction?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - reaction = map["reaction"] - } -} - -extension Fields where TypeLock == Objects.CreateReactionSuccess { - func reaction(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "reaction", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.reaction[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateReactionSuccess = Selection -} - -extension Objects { - struct CreateReminderError { - let __typename: TypeName = .createReminderError - let errorCodes: [String: [Enums.CreateReminderErrorCode]] - - enum TypeName: String, Codable { - case createReminderError = "CreateReminderError" - } - } -} - -extension Objects.CreateReminderError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.CreateReminderErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.CreateReminderError { - func errorCodes() throws -> [Enums.CreateReminderErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateReminderError = Selection -} - -extension Objects { - struct CreateReminderSuccess { - let __typename: TypeName = .createReminderSuccess - let reminder: [String: Objects.Reminder] - - enum TypeName: String, Codable { - case createReminderSuccess = "CreateReminderSuccess" - } - } -} - -extension Objects.CreateReminderSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "reminder": - if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - reminder = map["reminder"] - } -} - -extension Fields where TypeLock == Objects.CreateReminderSuccess { - func reminder(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "reminder", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.reminder[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateReminderSuccess = Selection -} - -extension Objects { - struct DeleteHighlightError { - let __typename: TypeName = .deleteHighlightError - let errorCodes: [String: [Enums.DeleteHighlightErrorCode]] - - enum TypeName: String, Codable { - case deleteHighlightError = "DeleteHighlightError" - } - } -} - -extension Objects.DeleteHighlightError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.DeleteHighlightErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.DeleteHighlightError { - func errorCodes() throws -> [Enums.DeleteHighlightErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteHighlightError = Selection -} - -extension Objects { - struct DeleteHighlightReplyError { - let __typename: TypeName = .deleteHighlightReplyError - let errorCodes: [String: [Enums.DeleteHighlightReplyErrorCode]] - - enum TypeName: String, Codable { - case deleteHighlightReplyError = "DeleteHighlightReplyError" - } - } -} - -extension Objects.DeleteHighlightReplyError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.DeleteHighlightReplyErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.DeleteHighlightReplyError { - func errorCodes() throws -> [Enums.DeleteHighlightReplyErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteHighlightReplyError = Selection -} - -extension Objects { - struct DeleteHighlightReplySuccess { - let __typename: TypeName = .deleteHighlightReplySuccess - let highlightReply: [String: Objects.HighlightReply] - - enum TypeName: String, Codable { - case deleteHighlightReplySuccess = "DeleteHighlightReplySuccess" - } - } -} - -extension Objects.DeleteHighlightReplySuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "highlightReply": - if let value = try container.decode(Objects.HighlightReply?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - highlightReply = map["highlightReply"] - } -} - -extension Fields where TypeLock == Objects.DeleteHighlightReplySuccess { - func highlightReply(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "highlightReply", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.highlightReply[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteHighlightReplySuccess = Selection -} - -extension Objects { - struct DeleteHighlightSuccess { - let __typename: TypeName = .deleteHighlightSuccess - let highlight: [String: Objects.Highlight] - - enum TypeName: String, Codable { - case deleteHighlightSuccess = "DeleteHighlightSuccess" - } - } -} - -extension Objects.DeleteHighlightSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "highlight": - if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - highlight = map["highlight"] - } -} - -extension Fields where TypeLock == Objects.DeleteHighlightSuccess { - func highlight(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "highlight", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.highlight[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteHighlightSuccess = Selection -} - -extension Objects { - struct DeleteLabelError { - let __typename: TypeName = .deleteLabelError - let errorCodes: [String: [Enums.DeleteLabelErrorCode]] - - enum TypeName: String, Codable { - case deleteLabelError = "DeleteLabelError" - } - } -} - -extension Objects.DeleteLabelError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.DeleteLabelErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.DeleteLabelError { - func errorCodes() throws -> [Enums.DeleteLabelErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteLabelError = Selection -} - -extension Objects { - struct DeleteLabelSuccess { - let __typename: TypeName = .deleteLabelSuccess - let label: [String: Objects.Label] - - enum TypeName: String, Codable { - case deleteLabelSuccess = "DeleteLabelSuccess" - } - } -} - -extension Objects.DeleteLabelSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "label": - if let value = try container.decode(Objects.Label?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - label = map["label"] - } -} - -extension Fields where TypeLock == Objects.DeleteLabelSuccess { - func label(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "label", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.label[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteLabelSuccess = Selection -} - -extension Objects { - struct DeleteNewsletterEmailError { - let __typename: TypeName = .deleteNewsletterEmailError - let errorCodes: [String: [Enums.DeleteNewsletterEmailErrorCode]] - - enum TypeName: String, Codable { - case deleteNewsletterEmailError = "DeleteNewsletterEmailError" - } - } -} - -extension Objects.DeleteNewsletterEmailError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.DeleteNewsletterEmailErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.DeleteNewsletterEmailError { - func errorCodes() throws -> [Enums.DeleteNewsletterEmailErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteNewsletterEmailError = Selection -} - -extension Objects { - struct DeleteNewsletterEmailSuccess { - let __typename: TypeName = .deleteNewsletterEmailSuccess - let newsletterEmail: [String: Objects.NewsletterEmail] - - enum TypeName: String, Codable { - case deleteNewsletterEmailSuccess = "DeleteNewsletterEmailSuccess" - } - } -} - -extension Objects.DeleteNewsletterEmailSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "newsletterEmail": - if let value = try container.decode(Objects.NewsletterEmail?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - newsletterEmail = map["newsletterEmail"] - } -} - -extension Fields where TypeLock == Objects.DeleteNewsletterEmailSuccess { - func newsletterEmail(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "newsletterEmail", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.newsletterEmail[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteNewsletterEmailSuccess = Selection -} - -extension Objects { - struct DeleteReactionError { - let __typename: TypeName = .deleteReactionError - let errorCodes: [String: [Enums.DeleteReactionErrorCode]] - - enum TypeName: String, Codable { - case deleteReactionError = "DeleteReactionError" - } - } -} - -extension Objects.DeleteReactionError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.DeleteReactionErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.DeleteReactionError { - func errorCodes() throws -> [Enums.DeleteReactionErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteReactionError = Selection -} - -extension Objects { - struct DeleteReactionSuccess { - let __typename: TypeName = .deleteReactionSuccess - let reaction: [String: Objects.Reaction] - - enum TypeName: String, Codable { - case deleteReactionSuccess = "DeleteReactionSuccess" - } - } -} - -extension Objects.DeleteReactionSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "reaction": - if let value = try container.decode(Objects.Reaction?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - reaction = map["reaction"] - } -} - -extension Fields where TypeLock == Objects.DeleteReactionSuccess { - func reaction(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "reaction", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.reaction[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteReactionSuccess = Selection -} - -extension Objects { - struct DeleteReminderError { - let __typename: TypeName = .deleteReminderError - let errorCodes: [String: [Enums.DeleteReminderErrorCode]] - - enum TypeName: String, Codable { - case deleteReminderError = "DeleteReminderError" - } - } -} - -extension Objects.DeleteReminderError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.DeleteReminderErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.DeleteReminderError { - func errorCodes() throws -> [Enums.DeleteReminderErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteReminderError = Selection -} - -extension Objects { - struct DeleteReminderSuccess { - let __typename: TypeName = .deleteReminderSuccess - let reminder: [String: Objects.Reminder] - - enum TypeName: String, Codable { - case deleteReminderSuccess = "DeleteReminderSuccess" - } - } -} - -extension Objects.DeleteReminderSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "reminder": - if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - reminder = map["reminder"] - } -} - -extension Fields where TypeLock == Objects.DeleteReminderSuccess { - func reminder(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "reminder", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.reminder[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteReminderSuccess = Selection -} - -extension Objects { - struct DeviceToken { - let __typename: TypeName = .deviceToken - let createdAt: [String: DateTime] - let id: [String: String] - let token: [String: String] - - enum TypeName: String, Codable { - case deviceToken = "DeviceToken" - } - } -} - -extension Objects.DeviceToken: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "createdAt": - if let value = try container.decode(DateTime?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "id": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "token": + case "message": if let value = try container.decode(String?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } @@ -3818,41 +4486,108 @@ extension Objects.DeviceToken: Decodable { } } - createdAt = map["createdAt"] - id = map["id"] - token = map["token"] + errorCodes = map["errorCodes"] + message = map["message"] } } -extension Fields where TypeLock == Objects.DeviceToken { - func createdAt() throws -> DateTime { +extension Fields where TypeLock == Objects.SaveError { + func errorCodes() throws -> [Enums.SaveErrorCode] { let field = GraphQLField.leaf( - name: "createdAt", + name: "errorCodes", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.createdAt[field.alias!] { + if let data = data.errorCodes[field.alias!] { return data } throw HttpError.badpayload case .mocking: - return DateTime.mockValue + return [] } } - func id() throws -> String { + func message() throws -> String? { let field = GraphQLField.leaf( - name: "id", + name: "message", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.id[field.alias!] { + return data.message[field.alias!] + case .mocking: + return nil + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SaveError = Selection +} + +extension Objects { + struct SaveSuccess { + let __typename: TypeName = .saveSuccess + let clientRequestId: [String: String] + let url: [String: String] + + enum TypeName: String, Codable { + case saveSuccess = "SaveSuccess" + } + } +} + +extension Objects.SaveSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "clientRequestId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "url": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + clientRequestId = map["clientRequestId"] + url = map["url"] + } +} + +extension Fields where TypeLock == Objects.SaveSuccess { + func url() throws -> String { + let field = GraphQLField.leaf( + name: "url", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.url[field.alias!] { return data } throw HttpError.badpayload @@ -3861,16 +4596,16 @@ extension Fields where TypeLock == Objects.DeviceToken { } } - func token() throws -> String { + func clientRequestId() throws -> String { let field = GraphQLField.leaf( - name: "token", + name: "clientRequestId", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.token[field.alias!] { + if let data = data.clientRequestId[field.alias!] { return data } throw HttpError.badpayload @@ -3881,7 +4616,531 @@ extension Fields where TypeLock == Objects.DeviceToken { } extension Selection where TypeLock == Never, Type == Never { - typealias DeviceToken = Selection + typealias SaveSuccess = Selection +} + +extension Objects { + struct UpdatePageSuccess { + let __typename: TypeName = .updatePageSuccess + let updatedPage: [String: Objects.Page] + + enum TypeName: String, Codable { + case updatePageSuccess = "UpdatePageSuccess" + } + } +} + +extension Objects.UpdatePageSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "updatedPage": + if let value = try container.decode(Objects.Page?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + updatedPage = map["updatedPage"] + } +} + +extension Fields where TypeLock == Objects.UpdatePageSuccess { + func updatedPage(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "updatedPage", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.updatedPage[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdatePageSuccess = Selection +} + +extension Objects { + struct UpdatePageError { + let __typename: TypeName = .updatePageError + let errorCodes: [String: [Enums.UpdatePageErrorCode]] + + enum TypeName: String, Codable { + case updatePageError = "UpdatePageError" + } + } +} + +extension Objects.UpdatePageError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdatePageErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.UpdatePageError { + func errorCodes() throws -> [Enums.UpdatePageErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdatePageError = Selection +} + +extension Objects { + struct SetFollowError { + let __typename: TypeName = .setFollowError + let errorCodes: [String: [Enums.SetFollowErrorCode]] + + enum TypeName: String, Codable { + case setFollowError = "SetFollowError" + } + } +} + +extension Objects.SetFollowError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SetFollowErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.SetFollowError { + func errorCodes() throws -> [Enums.SetFollowErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetFollowError = Selection +} + +extension Objects { + struct SetFollowSuccess { + let __typename: TypeName = .setFollowSuccess + let updatedUser: [String: Objects.User] + + enum TypeName: String, Codable { + case setFollowSuccess = "SetFollowSuccess" + } + } +} + +extension Objects.SetFollowSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "updatedUser": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + updatedUser = map["updatedUser"] + } +} + +extension Fields where TypeLock == Objects.SetFollowSuccess { + func updatedUser(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "updatedUser", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.updatedUser[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetFollowSuccess = Selection +} + +extension Objects { + struct SaveArticleReadingProgressError { + let __typename: TypeName = .saveArticleReadingProgressError + let errorCodes: [String: [Enums.SaveArticleReadingProgressErrorCode]] + + enum TypeName: String, Codable { + case saveArticleReadingProgressError = "SaveArticleReadingProgressError" + } + } +} + +extension Objects.SaveArticleReadingProgressError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SaveArticleReadingProgressErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.SaveArticleReadingProgressError { + func errorCodes() throws -> [Enums.SaveArticleReadingProgressErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SaveArticleReadingProgressError = Selection +} + +extension Objects { + struct SaveArticleReadingProgressSuccess { + let __typename: TypeName = .saveArticleReadingProgressSuccess + let updatedArticle: [String: Objects.Article] + + enum TypeName: String, Codable { + case saveArticleReadingProgressSuccess = "SaveArticleReadingProgressSuccess" + } + } +} + +extension Objects.SaveArticleReadingProgressSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "updatedArticle": + if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + updatedArticle = map["updatedArticle"] + } +} + +extension Fields where TypeLock == Objects.SaveArticleReadingProgressSuccess { + func updatedArticle(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "updatedArticle", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.updatedArticle[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SaveArticleReadingProgressSuccess = Selection +} + +extension Objects { + struct SetBookmarkArticleError { + let __typename: TypeName = .setBookmarkArticleError + let errorCodes: [String: [Enums.SetBookmarkArticleErrorCode]] + + enum TypeName: String, Codable { + case setBookmarkArticleError = "SetBookmarkArticleError" + } + } +} + +extension Objects.SetBookmarkArticleError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SetBookmarkArticleErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.SetBookmarkArticleError { + func errorCodes() throws -> [Enums.SetBookmarkArticleErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetBookmarkArticleError = Selection +} + +extension Objects { + struct SetBookmarkArticleSuccess { + let __typename: TypeName = .setBookmarkArticleSuccess + let bookmarkedArticle: [String: Objects.Article] + + enum TypeName: String, Codable { + case setBookmarkArticleSuccess = "SetBookmarkArticleSuccess" + } + } +} + +extension Objects.SetBookmarkArticleSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "bookmarkedArticle": + if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + bookmarkedArticle = map["bookmarkedArticle"] + } +} + +extension Fields where TypeLock == Objects.SetBookmarkArticleSuccess { + func bookmarkedArticle(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "bookmarkedArticle", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.bookmarkedArticle[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetBookmarkArticleSuccess = Selection } extension Objects { @@ -3980,18 +5239,21 @@ extension Objects.FeedArticle: Decodable { } extension Fields where TypeLock == Objects.FeedArticle { - func annotationsCount() throws -> Int? { + func id() throws -> String { let field = GraphQLField.leaf( - name: "annotationsCount", + name: "id", arguments: [] ) select(field) switch response { case let .decoding(data): - return data.annotationsCount[field.alias!] + if let data = data.id[field.alias!] { + return data + } + throw HttpError.badpayload case .mocking: - return nil + return String.mockValue } } @@ -4014,9 +5276,9 @@ extension Fields where TypeLock == Objects.FeedArticle { } } - func highlight(selection: Selection) throws -> Type { + func sharedBy(selection: Selection) throws -> Type { let field = GraphQLField.composite( - name: "highlight", + name: "sharedBy", arguments: [], selection: selection.selection ) @@ -4024,56 +5286,7 @@ extension Fields where TypeLock == Objects.FeedArticle { switch response { case let .decoding(data): - return try selection.decode(data: data.highlight[field.alias!]) - case .mocking: - return selection.mock() - } - } - - func highlightsCount() throws -> Int? { - let field = GraphQLField.leaf( - name: "highlightsCount", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.highlightsCount[field.alias!] - case .mocking: - return nil - } - } - - func id() throws -> String { - let field = GraphQLField.leaf( - name: "id", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.id[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func reactions(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "reactions", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.reactions[field.alias!] { + if let data = data.sharedBy[field.alias!] { return try selection.decode(data: data) } throw HttpError.badpayload @@ -4100,25 +5313,6 @@ extension Fields where TypeLock == Objects.FeedArticle { } } - func sharedBy(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "sharedBy", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.sharedBy[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - func sharedComment() throws -> String? { let field = GraphQLField.leaf( name: "sharedComment", @@ -4148,6 +5342,71 @@ extension Fields where TypeLock == Objects.FeedArticle { return nil } } + + func highlightsCount() throws -> Int? { + let field = GraphQLField.leaf( + name: "highlightsCount", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.highlightsCount[field.alias!] + case .mocking: + return nil + } + } + + func annotationsCount() throws -> Int? { + let field = GraphQLField.leaf( + name: "annotationsCount", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.annotationsCount[field.alias!] + case .mocking: + return nil + } + } + + func highlight(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "highlight", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + return try selection.decode(data: data.highlight[field.alias!]) + case .mocking: + return selection.mock() + } + } + + func reactions(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "reactions", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.reactions[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } } extension Selection where TypeLock == Never, Type == Never { @@ -4155,18 +5414,30 @@ extension Selection where TypeLock == Never, Type == Never { } extension Objects { - struct FeedArticleEdge { - let __typename: TypeName = .feedArticleEdge - let cursor: [String: String] - let node: [String: Objects.FeedArticle] + struct Highlight { + let __typename: TypeName = .highlight + let annotation: [String: String] + let createdAt: [String: DateTime] + let createdByMe: [String: Bool] + let id: [String: String] + let patch: [String: String] + let prefix: [String: String] + let quote: [String: String] + let reactions: [String: [Objects.Reaction]] + let replies: [String: [Objects.HighlightReply]] + let sharedAt: [String: DateTime] + let shortId: [String: String] + let suffix: [String: String] + let updatedAt: [String: DateTime] + let user: [String: Objects.User] enum TypeName: String, Codable { - case feedArticleEdge = "FeedArticleEdge" + case highlight = "Highlight" } } } -extension Objects.FeedArticleEdge: Decodable { +extension Objects.Highlight: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -4178,12 +5449,60 @@ extension Objects.FeedArticleEdge: Decodable { let field = GraphQLField.getFieldNameFromAlias(alias) switch field { - case "cursor": + case "annotation": if let value = try container.decode(String?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - case "node": - if let value = try container.decode(Objects.FeedArticle?.self, forKey: codingKey) { + case "createdAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "createdByMe": + if let value = try container.decode(Bool?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "id": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "patch": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "prefix": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "quote": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "reactions": + if let value = try container.decode([Objects.Reaction]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "replies": + if let value = try container.decode([Objects.HighlightReply]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "sharedAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "shortId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "suffix": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "updatedAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "user": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } default: @@ -4196,22 +5515,34 @@ extension Objects.FeedArticleEdge: Decodable { } } - cursor = map["cursor"] - node = map["node"] + annotation = map["annotation"] + createdAt = map["createdAt"] + createdByMe = map["createdByMe"] + id = map["id"] + patch = map["patch"] + prefix = map["prefix"] + quote = map["quote"] + reactions = map["reactions"] + replies = map["replies"] + sharedAt = map["sharedAt"] + shortId = map["shortId"] + suffix = map["suffix"] + updatedAt = map["updatedAt"] + user = map["user"] } } -extension Fields where TypeLock == Objects.FeedArticleEdge { - func cursor() throws -> String { +extension Fields where TypeLock == Objects.Highlight { + func id() throws -> String { let field = GraphQLField.leaf( - name: "cursor", + name: "id", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.cursor[field.alias!] { + if let data = data.id[field.alias!] { return data } throw HttpError.badpayload @@ -4220,9 +5551,27 @@ extension Fields where TypeLock == Objects.FeedArticleEdge { } } - func node(selection: Selection) throws -> Type { + func shortId() throws -> String { + let field = GraphQLField.leaf( + name: "shortId", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.shortId[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func user(selection: Selection) throws -> Type { let field = GraphQLField.composite( - name: "node", + name: "user", arguments: [], selection: selection.selection ) @@ -4230,7 +5579,261 @@ extension Fields where TypeLock == Objects.FeedArticleEdge { switch response { case let .decoding(data): - if let data = data.node[field.alias!] { + if let data = data.user[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func quote() throws -> String { + let field = GraphQLField.leaf( + name: "quote", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.quote[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func prefix() throws -> String? { + let field = GraphQLField.leaf( + name: "prefix", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.prefix[field.alias!] + case .mocking: + return nil + } + } + + func suffix() throws -> String? { + let field = GraphQLField.leaf( + name: "suffix", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.suffix[field.alias!] + case .mocking: + return nil + } + } + + func patch() throws -> String { + let field = GraphQLField.leaf( + name: "patch", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.patch[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func annotation() throws -> String? { + let field = GraphQLField.leaf( + name: "annotation", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.annotation[field.alias!] + case .mocking: + return nil + } + } + + func replies(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "replies", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.replies[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func sharedAt() throws -> DateTime? { + let field = GraphQLField.leaf( + name: "sharedAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.sharedAt[field.alias!] + case .mocking: + return nil + } + } + + func createdAt() throws -> DateTime { + let field = GraphQLField.leaf( + name: "createdAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.createdAt[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return DateTime.mockValue + } + } + + func updatedAt() throws -> DateTime { + let field = GraphQLField.leaf( + name: "updatedAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.updatedAt[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return DateTime.mockValue + } + } + + func reactions(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "reactions", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.reactions[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func createdByMe() throws -> Bool { + let field = GraphQLField.leaf( + name: "createdByMe", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.createdByMe[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Bool.mockValue + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias Highlight = Selection +} + +extension Objects { + struct CreateHighlightSuccess { + let __typename: TypeName = .createHighlightSuccess + let highlight: [String: Objects.Highlight] + + enum TypeName: String, Codable { + case createHighlightSuccess = "CreateHighlightSuccess" + } + } +} + +extension Objects.CreateHighlightSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "highlight": + if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + highlight = map["highlight"] + } +} + +extension Fields where TypeLock == Objects.CreateHighlightSuccess { + func highlight(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "highlight", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.highlight[field.alias!] { return try selection.decode(data: data) } throw HttpError.badpayload @@ -4241,7 +5844,1490 @@ extension Fields where TypeLock == Objects.FeedArticleEdge { } extension Selection where TypeLock == Never, Type == Never { - typealias FeedArticleEdge = Selection + typealias CreateHighlightSuccess = Selection +} + +extension Objects { + struct CreateHighlightError { + let __typename: TypeName = .createHighlightError + let errorCodes: [String: [Enums.CreateHighlightErrorCode]] + + enum TypeName: String, Codable { + case createHighlightError = "CreateHighlightError" + } + } +} + +extension Objects.CreateHighlightError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.CreateHighlightErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.CreateHighlightError { + func errorCodes() throws -> [Enums.CreateHighlightErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateHighlightError = Selection +} + +extension Objects { + struct MergeHighlightSuccess { + let __typename: TypeName = .mergeHighlightSuccess + let highlight: [String: Objects.Highlight] + let overlapHighlightIdList: [String: [String]] + + enum TypeName: String, Codable { + case mergeHighlightSuccess = "MergeHighlightSuccess" + } + } +} + +extension Objects.MergeHighlightSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "highlight": + if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "overlapHighlightIdList": + if let value = try container.decode([String]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + highlight = map["highlight"] + overlapHighlightIdList = map["overlapHighlightIdList"] + } +} + +extension Fields where TypeLock == Objects.MergeHighlightSuccess { + func highlight(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "highlight", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.highlight[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func overlapHighlightIdList() throws -> [String] { + let field = GraphQLField.leaf( + name: "overlapHighlightIdList", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.overlapHighlightIdList[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias MergeHighlightSuccess = Selection +} + +extension Objects { + struct MergeHighlightError { + let __typename: TypeName = .mergeHighlightError + let errorCodes: [String: [Enums.MergeHighlightErrorCode]] + + enum TypeName: String, Codable { + case mergeHighlightError = "MergeHighlightError" + } + } +} + +extension Objects.MergeHighlightError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.MergeHighlightErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.MergeHighlightError { + func errorCodes() throws -> [Enums.MergeHighlightErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias MergeHighlightError = Selection +} + +extension Objects { + struct UpdateHighlightSuccess { + let __typename: TypeName = .updateHighlightSuccess + let highlight: [String: Objects.Highlight] + + enum TypeName: String, Codable { + case updateHighlightSuccess = "UpdateHighlightSuccess" + } + } +} + +extension Objects.UpdateHighlightSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "highlight": + if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + highlight = map["highlight"] + } +} + +extension Fields where TypeLock == Objects.UpdateHighlightSuccess { + func highlight(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "highlight", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.highlight[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateHighlightSuccess = Selection +} + +extension Objects { + struct UpdateHighlightError { + let __typename: TypeName = .updateHighlightError + let errorCodes: [String: [Enums.UpdateHighlightErrorCode]] + + enum TypeName: String, Codable { + case updateHighlightError = "UpdateHighlightError" + } + } +} + +extension Objects.UpdateHighlightError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdateHighlightErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.UpdateHighlightError { + func errorCodes() throws -> [Enums.UpdateHighlightErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateHighlightError = Selection +} + +extension Objects { + struct DeleteHighlightSuccess { + let __typename: TypeName = .deleteHighlightSuccess + let highlight: [String: Objects.Highlight] + + enum TypeName: String, Codable { + case deleteHighlightSuccess = "DeleteHighlightSuccess" + } + } +} + +extension Objects.DeleteHighlightSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "highlight": + if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + highlight = map["highlight"] + } +} + +extension Fields where TypeLock == Objects.DeleteHighlightSuccess { + func highlight(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "highlight", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.highlight[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteHighlightSuccess = Selection +} + +extension Objects { + struct DeleteHighlightError { + let __typename: TypeName = .deleteHighlightError + let errorCodes: [String: [Enums.DeleteHighlightErrorCode]] + + enum TypeName: String, Codable { + case deleteHighlightError = "DeleteHighlightError" + } + } +} + +extension Objects.DeleteHighlightError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.DeleteHighlightErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.DeleteHighlightError { + func errorCodes() throws -> [Enums.DeleteHighlightErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteHighlightError = Selection +} + +extension Objects { + struct HighlightReply { + let __typename: TypeName = .highlightReply + let createdAt: [String: DateTime] + let highlight: [String: Objects.Highlight] + let id: [String: String] + let text: [String: String] + let updatedAt: [String: DateTime] + let user: [String: Objects.User] + + enum TypeName: String, Codable { + case highlightReply = "HighlightReply" + } + } +} + +extension Objects.HighlightReply: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "createdAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "highlight": + if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "id": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "text": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "updatedAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "user": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + createdAt = map["createdAt"] + highlight = map["highlight"] + id = map["id"] + text = map["text"] + updatedAt = map["updatedAt"] + user = map["user"] + } +} + +extension Fields where TypeLock == Objects.HighlightReply { + func id() throws -> String { + let field = GraphQLField.leaf( + name: "id", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.id[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func user(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "user", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.user[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func highlight(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "highlight", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.highlight[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func text() throws -> String { + let field = GraphQLField.leaf( + name: "text", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.text[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func createdAt() throws -> DateTime { + let field = GraphQLField.leaf( + name: "createdAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.createdAt[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return DateTime.mockValue + } + } + + func updatedAt() throws -> DateTime { + let field = GraphQLField.leaf( + name: "updatedAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.updatedAt[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return DateTime.mockValue + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias HighlightReply = Selection +} + +extension Objects { + struct CreateHighlightReplySuccess { + let __typename: TypeName = .createHighlightReplySuccess + let highlightReply: [String: Objects.HighlightReply] + + enum TypeName: String, Codable { + case createHighlightReplySuccess = "CreateHighlightReplySuccess" + } + } +} + +extension Objects.CreateHighlightReplySuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "highlightReply": + if let value = try container.decode(Objects.HighlightReply?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + highlightReply = map["highlightReply"] + } +} + +extension Fields where TypeLock == Objects.CreateHighlightReplySuccess { + func highlightReply(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "highlightReply", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.highlightReply[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateHighlightReplySuccess = Selection +} + +extension Objects { + struct CreateHighlightReplyError { + let __typename: TypeName = .createHighlightReplyError + let errorCodes: [String: [Enums.CreateHighlightReplyErrorCode]] + + enum TypeName: String, Codable { + case createHighlightReplyError = "CreateHighlightReplyError" + } + } +} + +extension Objects.CreateHighlightReplyError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.CreateHighlightReplyErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.CreateHighlightReplyError { + func errorCodes() throws -> [Enums.CreateHighlightReplyErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateHighlightReplyError = Selection +} + +extension Objects { + struct UpdateHighlightReplySuccess { + let __typename: TypeName = .updateHighlightReplySuccess + let highlightReply: [String: Objects.HighlightReply] + + enum TypeName: String, Codable { + case updateHighlightReplySuccess = "UpdateHighlightReplySuccess" + } + } +} + +extension Objects.UpdateHighlightReplySuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "highlightReply": + if let value = try container.decode(Objects.HighlightReply?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + highlightReply = map["highlightReply"] + } +} + +extension Fields where TypeLock == Objects.UpdateHighlightReplySuccess { + func highlightReply(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "highlightReply", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.highlightReply[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateHighlightReplySuccess = Selection +} + +extension Objects { + struct UpdateHighlightReplyError { + let __typename: TypeName = .updateHighlightReplyError + let errorCodes: [String: [Enums.UpdateHighlightReplyErrorCode]] + + enum TypeName: String, Codable { + case updateHighlightReplyError = "UpdateHighlightReplyError" + } + } +} + +extension Objects.UpdateHighlightReplyError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdateHighlightReplyErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.UpdateHighlightReplyError { + func errorCodes() throws -> [Enums.UpdateHighlightReplyErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateHighlightReplyError = Selection +} + +extension Objects { + struct DeleteHighlightReplySuccess { + let __typename: TypeName = .deleteHighlightReplySuccess + let highlightReply: [String: Objects.HighlightReply] + + enum TypeName: String, Codable { + case deleteHighlightReplySuccess = "DeleteHighlightReplySuccess" + } + } +} + +extension Objects.DeleteHighlightReplySuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "highlightReply": + if let value = try container.decode(Objects.HighlightReply?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + highlightReply = map["highlightReply"] + } +} + +extension Fields where TypeLock == Objects.DeleteHighlightReplySuccess { + func highlightReply(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "highlightReply", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.highlightReply[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteHighlightReplySuccess = Selection +} + +extension Objects { + struct DeleteHighlightReplyError { + let __typename: TypeName = .deleteHighlightReplyError + let errorCodes: [String: [Enums.DeleteHighlightReplyErrorCode]] + + enum TypeName: String, Codable { + case deleteHighlightReplyError = "DeleteHighlightReplyError" + } + } +} + +extension Objects.DeleteHighlightReplyError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.DeleteHighlightReplyErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.DeleteHighlightReplyError { + func errorCodes() throws -> [Enums.DeleteHighlightReplyErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteHighlightReplyError = Selection +} + +extension Objects { + struct Reaction { + let __typename: TypeName = .reaction + let code: [String: Enums.ReactionType] + let createdAt: [String: DateTime] + let id: [String: String] + let updatedAt: [String: DateTime] + let user: [String: Objects.User] + + enum TypeName: String, Codable { + case reaction = "Reaction" + } + } +} + +extension Objects.Reaction: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "code": + if let value = try container.decode(Enums.ReactionType?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "createdAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "id": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "updatedAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "user": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + code = map["code"] + createdAt = map["createdAt"] + id = map["id"] + updatedAt = map["updatedAt"] + user = map["user"] + } +} + +extension Fields where TypeLock == Objects.Reaction { + func id() throws -> String { + let field = GraphQLField.leaf( + name: "id", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.id[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func user(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "user", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.user[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func code() throws -> Enums.ReactionType { + let field = GraphQLField.leaf( + name: "code", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.code[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Enums.ReactionType.allCases.first! + } + } + + func createdAt() throws -> DateTime { + let field = GraphQLField.leaf( + name: "createdAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.createdAt[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return DateTime.mockValue + } + } + + func updatedAt() throws -> DateTime? { + let field = GraphQLField.leaf( + name: "updatedAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.updatedAt[field.alias!] + case .mocking: + return nil + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias Reaction = Selection +} + +extension Objects { + struct CreateReactionSuccess { + let __typename: TypeName = .createReactionSuccess + let reaction: [String: Objects.Reaction] + + enum TypeName: String, Codable { + case createReactionSuccess = "CreateReactionSuccess" + } + } +} + +extension Objects.CreateReactionSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "reaction": + if let value = try container.decode(Objects.Reaction?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + reaction = map["reaction"] + } +} + +extension Fields where TypeLock == Objects.CreateReactionSuccess { + func reaction(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "reaction", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.reaction[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateReactionSuccess = Selection +} + +extension Objects { + struct CreateReactionError { + let __typename: TypeName = .createReactionError + let errorCodes: [String: [Enums.CreateReactionErrorCode]] + + enum TypeName: String, Codable { + case createReactionError = "CreateReactionError" + } + } +} + +extension Objects.CreateReactionError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.CreateReactionErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.CreateReactionError { + func errorCodes() throws -> [Enums.CreateReactionErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateReactionError = Selection +} + +extension Objects { + struct DeleteReactionSuccess { + let __typename: TypeName = .deleteReactionSuccess + let reaction: [String: Objects.Reaction] + + enum TypeName: String, Codable { + case deleteReactionSuccess = "DeleteReactionSuccess" + } + } +} + +extension Objects.DeleteReactionSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "reaction": + if let value = try container.decode(Objects.Reaction?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + reaction = map["reaction"] + } +} + +extension Fields where TypeLock == Objects.DeleteReactionSuccess { + func reaction(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "reaction", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.reaction[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteReactionSuccess = Selection +} + +extension Objects { + struct DeleteReactionError { + let __typename: TypeName = .deleteReactionError + let errorCodes: [String: [Enums.DeleteReactionErrorCode]] + + enum TypeName: String, Codable { + case deleteReactionError = "DeleteReactionError" + } + } +} + +extension Objects.DeleteReactionError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.DeleteReactionErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.DeleteReactionError { + func errorCodes() throws -> [Enums.DeleteReactionErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteReactionError = Selection } extension Objects { @@ -4401,17 +7487,126 @@ extension Selection where TypeLock == Never, Type == Never { } extension Objects { - struct GenerateApiKeyError { - let __typename: TypeName = .generateApiKeyError - let errorCodes: [String: [Enums.GenerateApiKeyErrorCode]] + struct SetShareArticleSuccess { + let __typename: TypeName = .setShareArticleSuccess + let updatedArticle: [String: Objects.Article] + let updatedFeedArticle: [String: Objects.FeedArticle] + let updatedFeedArticleId: [String: String] enum TypeName: String, Codable { - case generateApiKeyError = "GenerateApiKeyError" + case setShareArticleSuccess = "SetShareArticleSuccess" } } } -extension Objects.GenerateApiKeyError: Decodable { +extension Objects.SetShareArticleSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "updatedArticle": + if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "updatedFeedArticle": + if let value = try container.decode(Objects.FeedArticle?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "updatedFeedArticleId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + updatedArticle = map["updatedArticle"] + updatedFeedArticle = map["updatedFeedArticle"] + updatedFeedArticleId = map["updatedFeedArticleId"] + } +} + +extension Fields where TypeLock == Objects.SetShareArticleSuccess { + func updatedFeedArticleId() throws -> String? { + let field = GraphQLField.leaf( + name: "updatedFeedArticleId", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.updatedFeedArticleId[field.alias!] + case .mocking: + return nil + } + } + + func updatedFeedArticle(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "updatedFeedArticle", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + return try selection.decode(data: data.updatedFeedArticle[field.alias!]) + case .mocking: + return selection.mock() + } + } + + func updatedArticle(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "updatedArticle", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.updatedArticle[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetShareArticleSuccess = Selection +} + +extension Objects { + struct SetShareArticleError { + let __typename: TypeName = .setShareArticleError + let errorCodes: [String: [Enums.SetShareArticleErrorCode]] + + enum TypeName: String, Codable { + case setShareArticleError = "SetShareArticleError" + } + } +} + +extension Objects.SetShareArticleError: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -4424,7 +7619,7 @@ extension Objects.GenerateApiKeyError: Decodable { switch field { case "errorCodes": - if let value = try container.decode([Enums.GenerateApiKeyErrorCode]?.self, forKey: codingKey) { + if let value = try container.decode([Enums.SetShareArticleErrorCode]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } default: @@ -4441,8 +7636,8 @@ extension Objects.GenerateApiKeyError: Decodable { } } -extension Fields where TypeLock == Objects.GenerateApiKeyError { - func errorCodes() throws -> [Enums.GenerateApiKeyErrorCode] { +extension Fields where TypeLock == Objects.SetShareArticleError { + func errorCodes() throws -> [Enums.SetShareArticleErrorCode] { let field = GraphQLField.leaf( name: "errorCodes", arguments: [] @@ -4462,21 +7657,22 @@ extension Fields where TypeLock == Objects.GenerateApiKeyError { } extension Selection where TypeLock == Never, Type == Never { - typealias GenerateApiKeyError = Selection + typealias SetShareArticleError = Selection } extension Objects { - struct GenerateApiKeySuccess { - let __typename: TypeName = .generateApiKeySuccess - let apiKey: [String: String] + struct UpdateSharedCommentSuccess { + let __typename: TypeName = .updateSharedCommentSuccess + let articleId: [String: String] + let sharedComment: [String: String] enum TypeName: String, Codable { - case generateApiKeySuccess = "GenerateApiKeySuccess" + case updateSharedCommentSuccess = "UpdateSharedCommentSuccess" } } } -extension Objects.GenerateApiKeySuccess: Decodable { +extension Objects.UpdateSharedCommentSuccess: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -4488,7 +7684,11 @@ extension Objects.GenerateApiKeySuccess: Decodable { let field = GraphQLField.getFieldNameFromAlias(alias) switch field { - case "apiKey": + case "articleId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "sharedComment": if let value = try container.decode(String?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } @@ -4502,21 +7702,40 @@ extension Objects.GenerateApiKeySuccess: Decodable { } } - apiKey = map["apiKey"] + articleId = map["articleId"] + sharedComment = map["sharedComment"] } } -extension Fields where TypeLock == Objects.GenerateApiKeySuccess { - func apiKey() throws -> String { +extension Fields where TypeLock == Objects.UpdateSharedCommentSuccess { + func articleId() throws -> String { let field = GraphQLField.leaf( - name: "apiKey", + name: "articleID", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.apiKey[field.alias!] { + if let data = data.articleId[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func sharedComment() throws -> String { + let field = GraphQLField.leaf( + name: "sharedComment", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.sharedComment[field.alias!] { return data } throw HttpError.badpayload @@ -4527,7 +7746,72 @@ extension Fields where TypeLock == Objects.GenerateApiKeySuccess { } extension Selection where TypeLock == Never, Type == Never { - typealias GenerateApiKeySuccess = Selection + typealias UpdateSharedCommentSuccess = Selection +} + +extension Objects { + struct UpdateSharedCommentError { + let __typename: TypeName = .updateSharedCommentError + let errorCodes: [String: [Enums.UpdateSharedCommentErrorCode]] + + enum TypeName: String, Codable { + case updateSharedCommentError = "UpdateSharedCommentError" + } + } +} + +extension Objects.UpdateSharedCommentError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdateSharedCommentErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.UpdateSharedCommentError { + func errorCodes() throws -> [Enums.UpdateSharedCommentErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateSharedCommentError = Selection } extension Objects { @@ -4792,6 +8076,194 @@ extension Selection where TypeLock == Never, Type == Never { typealias GetFollowingSuccess = Selection } +extension Objects { + struct UserPersonalization { + let __typename: TypeName = .userPersonalization + let fontFamily: [String: String] + let fontSize: [String: Int] + let id: [String: String] + let libraryLayoutType: [String: String] + let librarySortOrder: [String: Enums.SortOrder] + let margin: [String: Int] + let theme: [String: String] + + enum TypeName: String, Codable { + case userPersonalization = "UserPersonalization" + } + } +} + +extension Objects.UserPersonalization: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "fontFamily": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "fontSize": + if let value = try container.decode(Int?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "id": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "libraryLayoutType": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "librarySortOrder": + if let value = try container.decode(Enums.SortOrder?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "margin": + if let value = try container.decode(Int?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "theme": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + fontFamily = map["fontFamily"] + fontSize = map["fontSize"] + id = map["id"] + libraryLayoutType = map["libraryLayoutType"] + librarySortOrder = map["librarySortOrder"] + margin = map["margin"] + theme = map["theme"] + } +} + +extension Fields where TypeLock == Objects.UserPersonalization { + func id() throws -> String? { + let field = GraphQLField.leaf( + name: "id", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.id[field.alias!] + case .mocking: + return nil + } + } + + func theme() throws -> String? { + let field = GraphQLField.leaf( + name: "theme", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.theme[field.alias!] + case .mocking: + return nil + } + } + + func fontSize() throws -> Int? { + let field = GraphQLField.leaf( + name: "fontSize", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.fontSize[field.alias!] + case .mocking: + return nil + } + } + + func fontFamily() throws -> String? { + let field = GraphQLField.leaf( + name: "fontFamily", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.fontFamily[field.alias!] + case .mocking: + return nil + } + } + + func margin() throws -> Int? { + let field = GraphQLField.leaf( + name: "margin", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.margin[field.alias!] + case .mocking: + return nil + } + } + + func libraryLayoutType() throws -> String? { + let field = GraphQLField.leaf( + name: "libraryLayoutType", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.libraryLayoutType[field.alias!] + case .mocking: + return nil + } + } + + func librarySortOrder() throws -> Enums.SortOrder? { + let field = GraphQLField.leaf( + name: "librarySortOrder", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.librarySortOrder[field.alias!] + case .mocking: + return nil + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UserPersonalization = Selection +} + extension Objects { struct GetUserPersonalizationError { let __typename: TypeName = .getUserPersonalizationError @@ -4921,17 +8393,17 @@ extension Selection where TypeLock == Never, Type == Never { } extension Objects { - struct GoogleSignupError { - let __typename: TypeName = .googleSignupError - let errorCodes: [String: [Enums.SignupErrorCode?]] + struct SetUserPersonalizationError { + let __typename: TypeName = .setUserPersonalizationError + let errorCodes: [String: [Enums.SetUserPersonalizationErrorCode]] enum TypeName: String, Codable { - case googleSignupError = "GoogleSignupError" + case setUserPersonalizationError = "SetUserPersonalizationError" } } } -extension Objects.GoogleSignupError: Decodable { +extension Objects.SetUserPersonalizationError: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -4944,7 +8416,7 @@ extension Objects.GoogleSignupError: Decodable { switch field { case "errorCodes": - if let value = try container.decode([Enums.SignupErrorCode?]?.self, forKey: codingKey) { + if let value = try container.decode([Enums.SetUserPersonalizationErrorCode]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } default: @@ -4961,8 +8433,8 @@ extension Objects.GoogleSignupError: Decodable { } } -extension Fields where TypeLock == Objects.GoogleSignupError { - func errorCodes() throws -> [Enums.SignupErrorCode?] { +extension Fields where TypeLock == Objects.SetUserPersonalizationError { + func errorCodes() throws -> [Enums.SetUserPersonalizationErrorCode] { let field = GraphQLField.leaf( name: "errorCodes", arguments: [] @@ -4982,21 +8454,21 @@ extension Fields where TypeLock == Objects.GoogleSignupError { } extension Selection where TypeLock == Never, Type == Never { - typealias GoogleSignupError = Selection + typealias SetUserPersonalizationError = Selection } extension Objects { - struct GoogleSignupSuccess { - let __typename: TypeName = .googleSignupSuccess - let me: [String: Objects.User] + struct SetUserPersonalizationSuccess { + let __typename: TypeName = .setUserPersonalizationSuccess + let updatedUserPersonalization: [String: Objects.UserPersonalization] enum TypeName: String, Codable { - case googleSignupSuccess = "GoogleSignupSuccess" + case setUserPersonalizationSuccess = "SetUserPersonalizationSuccess" } } } -extension Objects.GoogleSignupSuccess: Decodable { +extension Objects.SetUserPersonalizationSuccess: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -5008,8 +8480,8 @@ extension Objects.GoogleSignupSuccess: Decodable { let field = GraphQLField.getFieldNameFromAlias(alias) switch field { - case "me": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + case "updatedUserPersonalization": + if let value = try container.decode(Objects.UserPersonalization?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } default: @@ -5022,14 +8494,14 @@ extension Objects.GoogleSignupSuccess: Decodable { } } - me = map["me"] + updatedUserPersonalization = map["updatedUserPersonalization"] } } -extension Fields where TypeLock == Objects.GoogleSignupSuccess { - func me(selection: Selection) throws -> Type { +extension Fields where TypeLock == Objects.SetUserPersonalizationSuccess { + func updatedUserPersonalization(selection: Selection) throws -> Type { let field = GraphQLField.composite( - name: "me", + name: "updatedUserPersonalization", arguments: [], selection: selection.selection ) @@ -5037,7 +8509,7 @@ extension Fields where TypeLock == Objects.GoogleSignupSuccess { switch response { case let .decoding(data): - if let data = data.me[field.alias!] { + if let data = data.updatedUserPersonalization[field.alias!] { return try selection.decode(data: data) } throw HttpError.badpayload @@ -5048,34 +8520,29 @@ extension Fields where TypeLock == Objects.GoogleSignupSuccess { } extension Selection where TypeLock == Never, Type == Never { - typealias GoogleSignupSuccess = Selection + typealias SetUserPersonalizationSuccess = Selection } extension Objects { - struct Highlight { - let __typename: TypeName = .highlight - let annotation: [String: String] + struct ArticleSavingRequest { + let __typename: TypeName = .articleSavingRequest + let article: [String: Objects.Article] let createdAt: [String: DateTime] - let createdByMe: [String: Bool] + let errorCode: [String: Enums.CreateArticleErrorCode] let id: [String: String] - let patch: [String: String] - let prefix: [String: String] - let quote: [String: String] - let reactions: [String: [Objects.Reaction]] - let replies: [String: [Objects.HighlightReply]] - let sharedAt: [String: DateTime] - let shortId: [String: String] - let suffix: [String: String] + let slug: [String: String] + let status: [String: Enums.ArticleSavingRequestStatus] let updatedAt: [String: DateTime] let user: [String: Objects.User] + let userId: [String: String] enum TypeName: String, Codable { - case highlight = "Highlight" + case articleSavingRequest = "ArticleSavingRequest" } } } -extension Objects.Highlight: Decodable { +extension Objects.ArticleSavingRequest: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -5087,52 +8554,28 @@ extension Objects.Highlight: Decodable { let field = GraphQLField.getFieldNameFromAlias(alias) switch field { - case "annotation": - if let value = try container.decode(String?.self, forKey: codingKey) { + case "article": + if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } case "createdAt": if let value = try container.decode(DateTime?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - case "createdByMe": - if let value = try container.decode(Bool?.self, forKey: codingKey) { + case "errorCode": + if let value = try container.decode(Enums.CreateArticleErrorCode?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } case "id": if let value = try container.decode(String?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - case "patch": + case "slug": if let value = try container.decode(String?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - case "prefix": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "quote": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "reactions": - if let value = try container.decode([Objects.Reaction]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "replies": - if let value = try container.decode([Objects.HighlightReply]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "sharedAt": - if let value = try container.decode(DateTime?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "shortId": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "suffix": - if let value = try container.decode(String?.self, forKey: codingKey) { + case "status": + if let value = try container.decode(Enums.ArticleSavingRequestStatus?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } case "updatedAt": @@ -5143,6 +8586,10 @@ extension Objects.Highlight: Decodable { if let value = try container.decode(Objects.User?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } + case "userId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } default: throw DecodingError.dataCorrupted( DecodingError.Context( @@ -5153,75 +8600,19 @@ extension Objects.Highlight: Decodable { } } - annotation = map["annotation"] + article = map["article"] createdAt = map["createdAt"] - createdByMe = map["createdByMe"] + errorCode = map["errorCode"] id = map["id"] - patch = map["patch"] - prefix = map["prefix"] - quote = map["quote"] - reactions = map["reactions"] - replies = map["replies"] - sharedAt = map["sharedAt"] - shortId = map["shortId"] - suffix = map["suffix"] + slug = map["slug"] + status = map["status"] updatedAt = map["updatedAt"] user = map["user"] + userId = map["userId"] } } -extension Fields where TypeLock == Objects.Highlight { - func annotation() throws -> String? { - let field = GraphQLField.leaf( - name: "annotation", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.annotation[field.alias!] - case .mocking: - return nil - } - } - - func createdAt() throws -> DateTime { - let field = GraphQLField.leaf( - name: "createdAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.createdAt[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return DateTime.mockValue - } - } - - func createdByMe() throws -> Bool { - let field = GraphQLField.leaf( - name: "createdByMe", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.createdByMe[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Bool.mockValue - } - } - +extension Fields where TypeLock == Objects.ArticleSavingRequest { func id() throws -> String { let field = GraphQLField.leaf( name: "id", @@ -5240,16 +8631,17 @@ extension Fields where TypeLock == Objects.Highlight { } } - func patch() throws -> String { + @available(*, deprecated, message: "userId has been replaced with user") + func userId() throws -> String { let field = GraphQLField.leaf( - name: "patch", + name: "userId", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.patch[field.alias!] { + if let data = data.userId[field.alias!] { return data } throw HttpError.badpayload @@ -5258,143 +8650,6 @@ extension Fields where TypeLock == Objects.Highlight { } } - func prefix() throws -> String? { - let field = GraphQLField.leaf( - name: "prefix", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.prefix[field.alias!] - case .mocking: - return nil - } - } - - func quote() throws -> String { - let field = GraphQLField.leaf( - name: "quote", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.quote[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func reactions(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "reactions", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.reactions[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func replies(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "replies", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.replies[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func sharedAt() throws -> DateTime? { - let field = GraphQLField.leaf( - name: "sharedAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.sharedAt[field.alias!] - case .mocking: - return nil - } - } - - func shortId() throws -> String { - let field = GraphQLField.leaf( - name: "shortId", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.shortId[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func suffix() throws -> String? { - let field = GraphQLField.leaf( - name: "suffix", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.suffix[field.alias!] - case .mocking: - return nil - } - } - - func updatedAt() throws -> DateTime { - let field = GraphQLField.leaf( - name: "updatedAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.updatedAt[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return DateTime.mockValue - } - } - func user(selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "user", @@ -5413,84 +8668,75 @@ extension Fields where TypeLock == Objects.Highlight { return selection.mock() } } -} -extension Selection where TypeLock == Never, Type == Never { - typealias Highlight = Selection -} + @available(*, deprecated, message: "article has been replaced with slug") + func article(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "article", + arguments: [], + selection: selection.selection + ) + select(field) -extension Objects { - struct HighlightReply { - let __typename: TypeName = .highlightReply - let createdAt: [String: DateTime] - let highlight: [String: Objects.Highlight] - let id: [String: String] - let text: [String: String] - let updatedAt: [String: DateTime] - let user: [String: Objects.User] - - enum TypeName: String, Codable { - case highlightReply = "HighlightReply" + switch response { + case let .decoding(data): + return try selection.decode(data: data.article[field.alias!]) + case .mocking: + return selection.mock() } } -} -extension Objects.HighlightReply: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + func slug() throws -> String { + let field = GraphQLField.leaf( + name: "slug", + arguments: [] + ) + select(field) - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "createdAt": - if let value = try container.decode(DateTime?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "highlight": - if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "id": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "text": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "updatedAt": - if let value = try container.decode(DateTime?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "user": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) + switch response { + case let .decoding(data): + if let data = data.slug[field.alias!] { + return data } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func status() throws -> Enums.ArticleSavingRequestStatus { + let field = GraphQLField.leaf( + name: "status", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.status[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Enums.ArticleSavingRequestStatus.allCases.first! + } + } + + func errorCode() throws -> Enums.CreateArticleErrorCode? { + let field = GraphQLField.leaf( + name: "errorCode", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.errorCode[field.alias!] + case .mocking: + return nil } - - createdAt = map["createdAt"] - highlight = map["highlight"] - id = map["id"] - text = map["text"] - updatedAt = map["updatedAt"] - user = map["user"] } -} -extension Fields where TypeLock == Objects.HighlightReply { func createdAt() throws -> DateTime { let field = GraphQLField.leaf( name: "createdAt", @@ -5509,6 +8755,398 @@ extension Fields where TypeLock == Objects.HighlightReply { } } + func updatedAt() throws -> DateTime { + let field = GraphQLField.leaf( + name: "updatedAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.updatedAt[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return DateTime.mockValue + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ArticleSavingRequest = Selection +} + +extension Objects { + struct ArticleSavingRequestError { + let __typename: TypeName = .articleSavingRequestError + let errorCodes: [String: [Enums.ArticleSavingRequestErrorCode]] + + enum TypeName: String, Codable { + case articleSavingRequestError = "ArticleSavingRequestError" + } + } +} + +extension Objects.ArticleSavingRequestError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.ArticleSavingRequestErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.ArticleSavingRequestError { + func errorCodes() throws -> [Enums.ArticleSavingRequestErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ArticleSavingRequestError = Selection +} + +extension Objects { + struct ArticleSavingRequestSuccess { + let __typename: TypeName = .articleSavingRequestSuccess + let articleSavingRequest: [String: Objects.ArticleSavingRequest] + + enum TypeName: String, Codable { + case articleSavingRequestSuccess = "ArticleSavingRequestSuccess" + } + } +} + +extension Objects.ArticleSavingRequestSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "articleSavingRequest": + if let value = try container.decode(Objects.ArticleSavingRequest?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + articleSavingRequest = map["articleSavingRequest"] + } +} + +extension Fields where TypeLock == Objects.ArticleSavingRequestSuccess { + func articleSavingRequest(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "articleSavingRequest", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.articleSavingRequest[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ArticleSavingRequestSuccess = Selection +} + +extension Objects { + struct CreateArticleSavingRequestError { + let __typename: TypeName = .createArticleSavingRequestError + let errorCodes: [String: [Enums.CreateArticleSavingRequestErrorCode]] + + enum TypeName: String, Codable { + case createArticleSavingRequestError = "CreateArticleSavingRequestError" + } + } +} + +extension Objects.CreateArticleSavingRequestError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.CreateArticleSavingRequestErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.CreateArticleSavingRequestError { + func errorCodes() throws -> [Enums.CreateArticleSavingRequestErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateArticleSavingRequestError = Selection +} + +extension Objects { + struct CreateArticleSavingRequestSuccess { + let __typename: TypeName = .createArticleSavingRequestSuccess + let articleSavingRequest: [String: Objects.ArticleSavingRequest] + + enum TypeName: String, Codable { + case createArticleSavingRequestSuccess = "CreateArticleSavingRequestSuccess" + } + } +} + +extension Objects.CreateArticleSavingRequestSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "articleSavingRequest": + if let value = try container.decode(Objects.ArticleSavingRequest?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + articleSavingRequest = map["articleSavingRequest"] + } +} + +extension Fields where TypeLock == Objects.CreateArticleSavingRequestSuccess { + func articleSavingRequest(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "articleSavingRequest", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.articleSavingRequest[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateArticleSavingRequestSuccess = Selection +} + +extension Objects { + struct SetShareHighlightError { + let __typename: TypeName = .setShareHighlightError + let errorCodes: [String: [Enums.SetShareHighlightErrorCode]] + + enum TypeName: String, Codable { + case setShareHighlightError = "SetShareHighlightError" + } + } +} + +extension Objects.SetShareHighlightError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SetShareHighlightErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.SetShareHighlightError { + func errorCodes() throws -> [Enums.SetShareHighlightErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetShareHighlightError = Selection +} + +extension Objects { + struct SetShareHighlightSuccess { + let __typename: TypeName = .setShareHighlightSuccess + let highlight: [String: Objects.Highlight] + + enum TypeName: String, Codable { + case setShareHighlightSuccess = "SetShareHighlightSuccess" + } + } +} + +extension Objects.SetShareHighlightSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "highlight": + if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + highlight = map["highlight"] + } +} + +extension Fields where TypeLock == Objects.SetShareHighlightSuccess { func highlight(selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "highlight", @@ -5527,7 +9165,439 @@ extension Fields where TypeLock == Objects.HighlightReply { return selection.mock() } } +} +extension Selection where TypeLock == Never, Type == Never { + typealias SetShareHighlightSuccess = Selection +} + +extension Objects { + struct ReportItemResult { + let __typename: TypeName = .reportItemResult + let message: [String: String] + + enum TypeName: String, Codable { + case reportItemResult = "ReportItemResult" + } + } +} + +extension Objects.ReportItemResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "message": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + message = map["message"] + } +} + +extension Fields where TypeLock == Objects.ReportItemResult { + func message() throws -> String { + let field = GraphQLField.leaf( + name: "message", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.message[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ReportItemResult = Selection +} + +extension Objects { + struct UpdateLinkShareInfoError { + let __typename: TypeName = .updateLinkShareInfoError + let errorCodes: [String: [Enums.UpdateLinkShareInfoErrorCode]] + + enum TypeName: String, Codable { + case updateLinkShareInfoError = "UpdateLinkShareInfoError" + } + } +} + +extension Objects.UpdateLinkShareInfoError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdateLinkShareInfoErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.UpdateLinkShareInfoError { + func errorCodes() throws -> [Enums.UpdateLinkShareInfoErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateLinkShareInfoError = Selection +} + +extension Objects { + struct UpdateLinkShareInfoSuccess { + let __typename: TypeName = .updateLinkShareInfoSuccess + let message: [String: String] + + enum TypeName: String, Codable { + case updateLinkShareInfoSuccess = "UpdateLinkShareInfoSuccess" + } + } +} + +extension Objects.UpdateLinkShareInfoSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "message": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + message = map["message"] + } +} + +extension Fields where TypeLock == Objects.UpdateLinkShareInfoSuccess { + func message() throws -> String { + let field = GraphQLField.leaf( + name: "message", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.message[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateLinkShareInfoSuccess = Selection +} + +extension Objects { + struct ArchiveLinkError { + let __typename: TypeName = .archiveLinkError + let errorCodes: [String: [Enums.ArchiveLinkErrorCode]] + let message: [String: String] + + enum TypeName: String, Codable { + case archiveLinkError = "ArchiveLinkError" + } + } +} + +extension Objects.ArchiveLinkError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.ArchiveLinkErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "message": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + message = map["message"] + } +} + +extension Fields where TypeLock == Objects.ArchiveLinkError { + func message() throws -> String { + let field = GraphQLField.leaf( + name: "message", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.message[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func errorCodes() throws -> [Enums.ArchiveLinkErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ArchiveLinkError = Selection +} + +extension Objects { + struct ArchiveLinkSuccess { + let __typename: TypeName = .archiveLinkSuccess + let linkId: [String: String] + let message: [String: String] + + enum TypeName: String, Codable { + case archiveLinkSuccess = "ArchiveLinkSuccess" + } + } +} + +extension Objects.ArchiveLinkSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "linkId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "message": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + linkId = map["linkId"] + message = map["message"] + } +} + +extension Fields where TypeLock == Objects.ArchiveLinkSuccess { + func linkId() throws -> String { + let field = GraphQLField.leaf( + name: "linkId", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.linkId[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func message() throws -> String { + let field = GraphQLField.leaf( + name: "message", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.message[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ArchiveLinkSuccess = Selection +} + +extension Objects { + struct NewsletterEmail { + let __typename: TypeName = .newsletterEmail + let address: [String: String] + let confirmationCode: [String: String] + let id: [String: String] + + enum TypeName: String, Codable { + case newsletterEmail = "NewsletterEmail" + } + } +} + +extension Objects.NewsletterEmail: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "address": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "confirmationCode": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "id": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + address = map["address"] + confirmationCode = map["confirmationCode"] + id = map["id"] + } +} + +extension Fields where TypeLock == Objects.NewsletterEmail { func id() throws -> String { let field = GraphQLField.leaf( name: "id", @@ -5546,16 +9616,16 @@ extension Fields where TypeLock == Objects.HighlightReply { } } - func text() throws -> String { + func address() throws -> String { let field = GraphQLField.leaf( - name: "text", + name: "address", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.text[field.alias!] { + if let data = data.address[field.alias!] { return data } throw HttpError.badpayload @@ -5564,60 +9634,38 @@ extension Fields where TypeLock == Objects.HighlightReply { } } - func updatedAt() throws -> DateTime { + func confirmationCode() throws -> String? { let field = GraphQLField.leaf( - name: "updatedAt", + name: "confirmationCode", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.updatedAt[field.alias!] { - return data - } - throw HttpError.badpayload + return data.confirmationCode[field.alias!] case .mocking: - return DateTime.mockValue - } - } - - func user(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "user", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.user[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() + return nil } } } extension Selection where TypeLock == Never, Type == Never { - typealias HighlightReply = Selection + typealias NewsletterEmail = Selection } extension Objects { - struct HighlightStats { - let __typename: TypeName = .highlightStats - let highlightCount: [String: Int] + struct NewsletterEmailsSuccess { + let __typename: TypeName = .newsletterEmailsSuccess + let newsletterEmails: [String: [Objects.NewsletterEmail]] enum TypeName: String, Codable { - case highlightStats = "HighlightStats" + case newsletterEmailsSuccess = "NewsletterEmailsSuccess" } } } -extension Objects.HighlightStats: Decodable { +extension Objects.NewsletterEmailsSuccess: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -5629,8 +9677,8 @@ extension Objects.HighlightStats: Decodable { let field = GraphQLField.getFieldNameFromAlias(alias) switch field { - case "highlightCount": - if let value = try container.decode(Int?.self, forKey: codingKey) { + case "newsletterEmails": + if let value = try container.decode([Objects.NewsletterEmail]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } default: @@ -5643,32 +9691,1265 @@ extension Objects.HighlightStats: Decodable { } } - highlightCount = map["highlightCount"] + newsletterEmails = map["newsletterEmails"] } } -extension Fields where TypeLock == Objects.HighlightStats { - func highlightCount() throws -> Int { +extension Fields where TypeLock == Objects.NewsletterEmailsSuccess { + func newsletterEmails(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "newsletterEmails", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.newsletterEmails[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias NewsletterEmailsSuccess = Selection +} + +extension Objects { + struct NewsletterEmailsError { + let __typename: TypeName = .newsletterEmailsError + let errorCodes: [String: [Enums.NewsletterEmailsErrorCode]] + + enum TypeName: String, Codable { + case newsletterEmailsError = "NewsletterEmailsError" + } + } +} + +extension Objects.NewsletterEmailsError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.NewsletterEmailsErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.NewsletterEmailsError { + func errorCodes() throws -> [Enums.NewsletterEmailsErrorCode] { let field = GraphQLField.leaf( - name: "highlightCount", + name: "errorCodes", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.highlightCount[field.alias!] { + if let data = data.errorCodes[field.alias!] { return data } throw HttpError.badpayload case .mocking: - return Int.mockValue + return [] } } } extension Selection where TypeLock == Never, Type == Never { - typealias HighlightStats = Selection + typealias NewsletterEmailsError = Selection +} + +extension Objects { + struct CreateNewsletterEmailSuccess { + let __typename: TypeName = .createNewsletterEmailSuccess + let newsletterEmail: [String: Objects.NewsletterEmail] + + enum TypeName: String, Codable { + case createNewsletterEmailSuccess = "CreateNewsletterEmailSuccess" + } + } +} + +extension Objects.CreateNewsletterEmailSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "newsletterEmail": + if let value = try container.decode(Objects.NewsletterEmail?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + newsletterEmail = map["newsletterEmail"] + } +} + +extension Fields where TypeLock == Objects.CreateNewsletterEmailSuccess { + func newsletterEmail(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "newsletterEmail", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.newsletterEmail[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateNewsletterEmailSuccess = Selection +} + +extension Objects { + struct CreateNewsletterEmailError { + let __typename: TypeName = .createNewsletterEmailError + let errorCodes: [String: [Enums.CreateNewsletterEmailErrorCode]] + + enum TypeName: String, Codable { + case createNewsletterEmailError = "CreateNewsletterEmailError" + } + } +} + +extension Objects.CreateNewsletterEmailError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.CreateNewsletterEmailErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.CreateNewsletterEmailError { + func errorCodes() throws -> [Enums.CreateNewsletterEmailErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateNewsletterEmailError = Selection +} + +extension Objects { + struct DeleteNewsletterEmailSuccess { + let __typename: TypeName = .deleteNewsletterEmailSuccess + let newsletterEmail: [String: Objects.NewsletterEmail] + + enum TypeName: String, Codable { + case deleteNewsletterEmailSuccess = "DeleteNewsletterEmailSuccess" + } + } +} + +extension Objects.DeleteNewsletterEmailSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "newsletterEmail": + if let value = try container.decode(Objects.NewsletterEmail?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + newsletterEmail = map["newsletterEmail"] + } +} + +extension Fields where TypeLock == Objects.DeleteNewsletterEmailSuccess { + func newsletterEmail(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "newsletterEmail", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.newsletterEmail[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteNewsletterEmailSuccess = Selection +} + +extension Objects { + struct DeleteNewsletterEmailError { + let __typename: TypeName = .deleteNewsletterEmailError + let errorCodes: [String: [Enums.DeleteNewsletterEmailErrorCode]] + + enum TypeName: String, Codable { + case deleteNewsletterEmailError = "DeleteNewsletterEmailError" + } + } +} + +extension Objects.DeleteNewsletterEmailError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.DeleteNewsletterEmailErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.DeleteNewsletterEmailError { + func errorCodes() throws -> [Enums.DeleteNewsletterEmailErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteNewsletterEmailError = Selection +} + +extension Objects { + struct Reminder { + let __typename: TypeName = .reminder + let archiveUntil: [String: Bool] + let id: [String: String] + let remindAt: [String: DateTime] + let sendNotification: [String: Bool] + + enum TypeName: String, Codable { + case reminder = "Reminder" + } + } +} + +extension Objects.Reminder: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "archiveUntil": + if let value = try container.decode(Bool?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "id": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "remindAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "sendNotification": + if let value = try container.decode(Bool?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + archiveUntil = map["archiveUntil"] + id = map["id"] + remindAt = map["remindAt"] + sendNotification = map["sendNotification"] + } +} + +extension Fields where TypeLock == Objects.Reminder { + func id() throws -> String { + let field = GraphQLField.leaf( + name: "id", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.id[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func archiveUntil() throws -> Bool { + let field = GraphQLField.leaf( + name: "archiveUntil", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.archiveUntil[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Bool.mockValue + } + } + + func sendNotification() throws -> Bool { + let field = GraphQLField.leaf( + name: "sendNotification", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.sendNotification[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Bool.mockValue + } + } + + func remindAt() throws -> DateTime { + let field = GraphQLField.leaf( + name: "remindAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.remindAt[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return DateTime.mockValue + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias Reminder = Selection +} + +extension Objects { + struct ReminderSuccess { + let __typename: TypeName = .reminderSuccess + let reminder: [String: Objects.Reminder] + + enum TypeName: String, Codable { + case reminderSuccess = "ReminderSuccess" + } + } +} + +extension Objects.ReminderSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "reminder": + if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + reminder = map["reminder"] + } +} + +extension Fields where TypeLock == Objects.ReminderSuccess { + func reminder(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "reminder", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.reminder[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ReminderSuccess = Selection +} + +extension Objects { + struct ReminderError { + let __typename: TypeName = .reminderError + let errorCodes: [String: [Enums.ReminderErrorCode]] + + enum TypeName: String, Codable { + case reminderError = "ReminderError" + } + } +} + +extension Objects.ReminderError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.ReminderErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.ReminderError { + func errorCodes() throws -> [Enums.ReminderErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ReminderError = Selection +} + +extension Objects { + struct CreateReminderSuccess { + let __typename: TypeName = .createReminderSuccess + let reminder: [String: Objects.Reminder] + + enum TypeName: String, Codable { + case createReminderSuccess = "CreateReminderSuccess" + } + } +} + +extension Objects.CreateReminderSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "reminder": + if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + reminder = map["reminder"] + } +} + +extension Fields where TypeLock == Objects.CreateReminderSuccess { + func reminder(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "reminder", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.reminder[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateReminderSuccess = Selection +} + +extension Objects { + struct CreateReminderError { + let __typename: TypeName = .createReminderError + let errorCodes: [String: [Enums.CreateReminderErrorCode]] + + enum TypeName: String, Codable { + case createReminderError = "CreateReminderError" + } + } +} + +extension Objects.CreateReminderError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.CreateReminderErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.CreateReminderError { + func errorCodes() throws -> [Enums.CreateReminderErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateReminderError = Selection +} + +extension Objects { + struct UpdateReminderSuccess { + let __typename: TypeName = .updateReminderSuccess + let reminder: [String: Objects.Reminder] + + enum TypeName: String, Codable { + case updateReminderSuccess = "UpdateReminderSuccess" + } + } +} + +extension Objects.UpdateReminderSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "reminder": + if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + reminder = map["reminder"] + } +} + +extension Fields where TypeLock == Objects.UpdateReminderSuccess { + func reminder(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "reminder", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.reminder[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateReminderSuccess = Selection +} + +extension Objects { + struct UpdateReminderError { + let __typename: TypeName = .updateReminderError + let errorCodes: [String: [Enums.UpdateReminderErrorCode]] + + enum TypeName: String, Codable { + case updateReminderError = "UpdateReminderError" + } + } +} + +extension Objects.UpdateReminderError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdateReminderErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.UpdateReminderError { + func errorCodes() throws -> [Enums.UpdateReminderErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateReminderError = Selection +} + +extension Objects { + struct DeleteReminderSuccess { + let __typename: TypeName = .deleteReminderSuccess + let reminder: [String: Objects.Reminder] + + enum TypeName: String, Codable { + case deleteReminderSuccess = "DeleteReminderSuccess" + } + } +} + +extension Objects.DeleteReminderSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "reminder": + if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + reminder = map["reminder"] + } +} + +extension Fields where TypeLock == Objects.DeleteReminderSuccess { + func reminder(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "reminder", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.reminder[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteReminderSuccess = Selection +} + +extension Objects { + struct DeleteReminderError { + let __typename: TypeName = .deleteReminderError + let errorCodes: [String: [Enums.DeleteReminderErrorCode]] + + enum TypeName: String, Codable { + case deleteReminderError = "DeleteReminderError" + } + } +} + +extension Objects.DeleteReminderError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.DeleteReminderErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.DeleteReminderError { + func errorCodes() throws -> [Enums.DeleteReminderErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteReminderError = Selection +} + +extension Objects { + struct DeviceToken { + let __typename: TypeName = .deviceToken + let createdAt: [String: DateTime] + let id: [String: String] + let token: [String: String] + + enum TypeName: String, Codable { + case deviceToken = "DeviceToken" + } + } +} + +extension Objects.DeviceToken: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "createdAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "id": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "token": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + createdAt = map["createdAt"] + id = map["id"] + token = map["token"] + } +} + +extension Fields where TypeLock == Objects.DeviceToken { + func id() throws -> String { + let field = GraphQLField.leaf( + name: "id", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.id[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func token() throws -> String { + let field = GraphQLField.leaf( + name: "token", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.token[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func createdAt() throws -> DateTime { + let field = GraphQLField.leaf( + name: "createdAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.createdAt[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return DateTime.mockValue + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeviceToken = Selection +} + +extension Objects { + struct SetDeviceTokenSuccess { + let __typename: TypeName = .setDeviceTokenSuccess + let deviceToken: [String: Objects.DeviceToken] + + enum TypeName: String, Codable { + case setDeviceTokenSuccess = "SetDeviceTokenSuccess" + } + } +} + +extension Objects.SetDeviceTokenSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "deviceToken": + if let value = try container.decode(Objects.DeviceToken?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + deviceToken = map["deviceToken"] + } +} + +extension Fields where TypeLock == Objects.SetDeviceTokenSuccess { + func deviceToken(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "deviceToken", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.deviceToken[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetDeviceTokenSuccess = Selection +} + +extension Objects { + struct SetDeviceTokenError { + let __typename: TypeName = .setDeviceTokenError + let errorCodes: [String: [Enums.SetDeviceTokenErrorCode]] + + enum TypeName: String, Codable { + case setDeviceTokenError = "SetDeviceTokenError" + } + } +} + +extension Objects.SetDeviceTokenError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SetDeviceTokenErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.SetDeviceTokenError { + func errorCodes() throws -> [Enums.SetDeviceTokenErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetDeviceTokenError = Selection } extension Objects { @@ -5737,54 +11018,6 @@ extension Objects.Label: Decodable { } extension Fields where TypeLock == Objects.Label { - func color() throws -> String { - let field = GraphQLField.leaf( - name: "color", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.color[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func createdAt() throws -> DateTime? { - let field = GraphQLField.leaf( - name: "createdAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.createdAt[field.alias!] - case .mocking: - return nil - } - } - - func description() throws -> String? { - let field = GraphQLField.leaf( - name: "description", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.description[field.alias!] - case .mocking: - return nil - } - } - func id() throws -> String { let field = GraphQLField.leaf( name: "id", @@ -5820,75 +11053,58 @@ extension Fields where TypeLock == Objects.Label { return String.mockValue } } -} -extension Selection where TypeLock == Never, Type == Never { - typealias Label = Selection -} - -extension Objects { - struct LabelsError { - let __typename: TypeName = .labelsError - let errorCodes: [String: [Enums.LabelsErrorCode]] - - enum TypeName: String, Codable { - case labelsError = "LabelsError" - } - } -} - -extension Objects.LabelsError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.LabelsErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.LabelsError { - func errorCodes() throws -> [Enums.LabelsErrorCode] { + func color() throws -> String { let field = GraphQLField.leaf( - name: "errorCodes", + name: "color", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.errorCodes[field.alias!] { + if let data = data.color[field.alias!] { return data } throw HttpError.badpayload case .mocking: - return [] + return String.mockValue + } + } + + func description() throws -> String? { + let field = GraphQLField.leaf( + name: "description", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.description[field.alias!] + case .mocking: + return nil + } + } + + func createdAt() throws -> DateTime? { + let field = GraphQLField.leaf( + name: "createdAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.createdAt[field.alias!] + case .mocking: + return nil } } } extension Selection where TypeLock == Never, Type == Never { - typealias LabelsError = Selection + typealias Label = Selection } extension Objects { @@ -5958,28 +11174,17 @@ extension Selection where TypeLock == Never, Type == Never { } extension Objects { - struct Link { - let __typename: TypeName = .link - let highlightStats: [String: Objects.HighlightStats] - let id: [String: String] - let page: [String: Objects.Page] - let postedByViewer: [String: Bool] - let readState: [String: Objects.ReadState] - let savedAt: [String: DateTime] - let savedBy: [String: Objects.User] - let savedByViewer: [String: Bool] - let shareInfo: [String: Objects.LinkShareInfo] - let shareStats: [String: Objects.ShareStats] - let slug: [String: String] - let url: [String: String] + struct LabelsError { + let __typename: TypeName = .labelsError + let errorCodes: [String: [Enums.LabelsErrorCode]] enum TypeName: String, Codable { - case link = "Link" + case labelsError = "LabelsError" } } } -extension Objects.Link: Decodable { +extension Objects.LabelsError: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -5991,50 +11196,991 @@ extension Objects.Link: Decodable { let field = GraphQLField.getFieldNameFromAlias(alias) switch field { - case "highlightStats": - if let value = try container.decode(Objects.HighlightStats?.self, forKey: codingKey) { + case "errorCodes": + if let value = try container.decode([Enums.LabelsErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.LabelsError { + func errorCodes() throws -> [Enums.LabelsErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias LabelsError = Selection +} + +extension Objects { + struct CreateLabelSuccess { + let __typename: TypeName = .createLabelSuccess + let label: [String: Objects.Label] + + enum TypeName: String, Codable { + case createLabelSuccess = "CreateLabelSuccess" + } + } +} + +extension Objects.CreateLabelSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "label": + if let value = try container.decode(Objects.Label?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + label = map["label"] + } +} + +extension Fields where TypeLock == Objects.CreateLabelSuccess { + func label(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "label", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.label[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateLabelSuccess = Selection +} + +extension Objects { + struct CreateLabelError { + let __typename: TypeName = .createLabelError + let errorCodes: [String: [Enums.CreateLabelErrorCode]] + + enum TypeName: String, Codable { + case createLabelError = "CreateLabelError" + } + } +} + +extension Objects.CreateLabelError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.CreateLabelErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.CreateLabelError { + func errorCodes() throws -> [Enums.CreateLabelErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateLabelError = Selection +} + +extension Objects { + struct DeleteLabelSuccess { + let __typename: TypeName = .deleteLabelSuccess + let label: [String: Objects.Label] + + enum TypeName: String, Codable { + case deleteLabelSuccess = "DeleteLabelSuccess" + } + } +} + +extension Objects.DeleteLabelSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "label": + if let value = try container.decode(Objects.Label?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + label = map["label"] + } +} + +extension Fields where TypeLock == Objects.DeleteLabelSuccess { + func label(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "label", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.label[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteLabelSuccess = Selection +} + +extension Objects { + struct DeleteLabelError { + let __typename: TypeName = .deleteLabelError + let errorCodes: [String: [Enums.DeleteLabelErrorCode]] + + enum TypeName: String, Codable { + case deleteLabelError = "DeleteLabelError" + } + } +} + +extension Objects.DeleteLabelError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.DeleteLabelErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.DeleteLabelError { + func errorCodes() throws -> [Enums.DeleteLabelErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteLabelError = Selection +} + +extension Objects { + struct UpdateLabelSuccess { + let __typename: TypeName = .updateLabelSuccess + let label: [String: Objects.Label] + + enum TypeName: String, Codable { + case updateLabelSuccess = "UpdateLabelSuccess" + } + } +} + +extension Objects.UpdateLabelSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "label": + if let value = try container.decode(Objects.Label?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + label = map["label"] + } +} + +extension Fields where TypeLock == Objects.UpdateLabelSuccess { + func label(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "label", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.label[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateLabelSuccess = Selection +} + +extension Objects { + struct UpdateLabelError { + let __typename: TypeName = .updateLabelError + let errorCodes: [String: [Enums.UpdateLabelErrorCode]] + + enum TypeName: String, Codable { + case updateLabelError = "UpdateLabelError" + } + } +} + +extension Objects.UpdateLabelError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdateLabelErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.UpdateLabelError { + func errorCodes() throws -> [Enums.UpdateLabelErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateLabelError = Selection +} + +extension Objects { + struct SignupSuccess { + let __typename: TypeName = .signupSuccess + let me: [String: Objects.User] + + enum TypeName: String, Codable { + case signupSuccess = "SignupSuccess" + } + } +} + +extension Objects.SignupSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "me": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + me = map["me"] + } +} + +extension Fields where TypeLock == Objects.SignupSuccess { + func me(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "me", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.me[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SignupSuccess = Selection +} + +extension Objects { + struct SignupError { + let __typename: TypeName = .signupError + let errorCodes: [String: [Enums.SignupErrorCode?]] + + enum TypeName: String, Codable { + case signupError = "SignupError" + } + } +} + +extension Objects.SignupError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SignupErrorCode?]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.SignupError { + func errorCodes() throws -> [Enums.SignupErrorCode?] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SignupError = Selection +} + +extension Objects { + struct SetLabelsSuccess { + let __typename: TypeName = .setLabelsSuccess + let labels: [String: [Objects.Label]] + + enum TypeName: String, Codable { + case setLabelsSuccess = "SetLabelsSuccess" + } + } +} + +extension Objects.SetLabelsSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "labels": + if let value = try container.decode([Objects.Label]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + labels = map["labels"] + } +} + +extension Fields where TypeLock == Objects.SetLabelsSuccess { + func labels(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "labels", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.labels[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetLabelsSuccess = Selection +} + +extension Objects { + struct SetLabelsError { + let __typename: TypeName = .setLabelsError + let errorCodes: [String: [Enums.SetLabelsErrorCode]] + + enum TypeName: String, Codable { + case setLabelsError = "SetLabelsError" + } + } +} + +extension Objects.SetLabelsError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SetLabelsErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.SetLabelsError { + func errorCodes() throws -> [Enums.SetLabelsErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetLabelsError = Selection +} + +extension Objects { + struct GenerateApiKeySuccess { + let __typename: TypeName = .generateApiKeySuccess + let apiKey: [String: String] + + enum TypeName: String, Codable { + case generateApiKeySuccess = "GenerateApiKeySuccess" + } + } +} + +extension Objects.GenerateApiKeySuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "apiKey": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + apiKey = map["apiKey"] + } +} + +extension Fields where TypeLock == Objects.GenerateApiKeySuccess { + func apiKey() throws -> String { + let field = GraphQLField.leaf( + name: "apiKey", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.apiKey[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias GenerateApiKeySuccess = Selection +} + +extension Objects { + struct GenerateApiKeyError { + let __typename: TypeName = .generateApiKeyError + let errorCodes: [String: [Enums.GenerateApiKeyErrorCode]] + + enum TypeName: String, Codable { + case generateApiKeyError = "GenerateApiKeyError" + } + } +} + +extension Objects.GenerateApiKeyError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.GenerateApiKeyErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.GenerateApiKeyError { + func errorCodes() throws -> [Enums.GenerateApiKeyErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias GenerateApiKeyError = Selection +} + +extension Objects { + struct SearchItem { + let __typename: TypeName = .searchItem + let annotation: [String: String] + let author: [String: String] + let contentReader: [String: Enums.ContentReader] + let createdAt: [String: DateTime] + let description: [String: String] + let id: [String: String] + let image: [String: String] + let isArchived: [String: Bool] + let labels: [String: [Objects.Label]] + let language: [String: String] + let originalArticleUrl: [String: String] + let ownedByViewer: [String: Bool] + let pageId: [String: String] + let pageType: [String: Enums.PageType] + let publishedAt: [String: DateTime] + let quote: [String: String] + let readingProgressAnchorIndex: [String: Int] + let readingProgressPercent: [String: Double] + let shortId: [String: String] + let siteName: [String: String] + let slug: [String: String] + let state: [String: Enums.ArticleSavingRequestStatus] + let subscription: [String: String] + let title: [String: String] + let unsubHttpUrl: [String: String] + let unsubMailTo: [String: String] + let uploadFileId: [String: String] + let url: [String: String] + + enum TypeName: String, Codable { + case searchItem = "SearchItem" + } + } +} + +extension Objects.SearchItem: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "annotation": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "author": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "contentReader": + if let value = try container.decode(Enums.ContentReader?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "createdAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "description": + if let value = try container.decode(String?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } case "id": if let value = try container.decode(String?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - case "page": - if let value = try container.decode(Objects.Page?.self, forKey: codingKey) { + case "image": + if let value = try container.decode(String?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - case "postedByViewer": + case "isArchived": if let value = try container.decode(Bool?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - case "readState": - if let value = try container.decode(Objects.ReadState?.self, forKey: codingKey) { + case "labels": + if let value = try container.decode([Objects.Label]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - case "savedAt": + case "language": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "originalArticleUrl": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "ownedByViewer": + if let value = try container.decode(Bool?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "pageId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "pageType": + if let value = try container.decode(Enums.PageType?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "publishedAt": if let value = try container.decode(DateTime?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - case "savedBy": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + case "quote": + if let value = try container.decode(String?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - case "savedByViewer": - if let value = try container.decode(Bool?.self, forKey: codingKey) { + case "readingProgressAnchorIndex": + if let value = try container.decode(Int?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - case "shareInfo": - if let value = try container.decode(Objects.LinkShareInfo?.self, forKey: codingKey) { + case "readingProgressPercent": + if let value = try container.decode(Double?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - case "shareStats": - if let value = try container.decode(Objects.ShareStats?.self, forKey: codingKey) { + case "shortId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "siteName": + if let value = try container.decode(String?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } case "slug": if let value = try container.decode(String?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } + case "state": + if let value = try container.decode(Enums.ArticleSavingRequestStatus?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "subscription": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "title": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "unsubHttpUrl": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "unsubMailTo": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "uploadFileId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } case "url": if let value = try container.decode(String?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) @@ -6049,41 +12195,38 @@ extension Objects.Link: Decodable { } } - highlightStats = map["highlightStats"] + annotation = map["annotation"] + author = map["author"] + contentReader = map["contentReader"] + createdAt = map["createdAt"] + description = map["description"] id = map["id"] - page = map["page"] - postedByViewer = map["postedByViewer"] - readState = map["readState"] - savedAt = map["savedAt"] - savedBy = map["savedBy"] - savedByViewer = map["savedByViewer"] - shareInfo = map["shareInfo"] - shareStats = map["shareStats"] + image = map["image"] + isArchived = map["isArchived"] + labels = map["labels"] + language = map["language"] + originalArticleUrl = map["originalArticleUrl"] + ownedByViewer = map["ownedByViewer"] + pageId = map["pageId"] + pageType = map["pageType"] + publishedAt = map["publishedAt"] + quote = map["quote"] + readingProgressAnchorIndex = map["readingProgressAnchorIndex"] + readingProgressPercent = map["readingProgressPercent"] + shortId = map["shortId"] + siteName = map["siteName"] slug = map["slug"] + state = map["state"] + subscription = map["subscription"] + title = map["title"] + unsubHttpUrl = map["unsubHttpUrl"] + unsubMailTo = map["unsubMailTo"] + uploadFileId = map["uploadFileId"] url = map["url"] } } -extension Fields where TypeLock == Objects.Link { - func highlightStats(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "highlightStats", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.highlightStats[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - +extension Fields where TypeLock == Objects.SearchItem { func id() throws -> String { let field = GraphQLField.leaf( name: "id", @@ -6102,152 +12245,21 @@ extension Fields where TypeLock == Objects.Link { } } - func page(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "page", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.page[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func postedByViewer() throws -> Bool { + func title() throws -> String { let field = GraphQLField.leaf( - name: "postedByViewer", + name: "title", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.postedByViewer[field.alias!] { + if let data = data.title[field.alias!] { return data } throw HttpError.badpayload case .mocking: - return Bool.mockValue - } - } - - func readState(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "readState", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.readState[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func savedAt() throws -> DateTime { - let field = GraphQLField.leaf( - name: "savedAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.savedAt[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return DateTime.mockValue - } - } - - func savedBy(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "savedBy", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.savedBy[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func savedByViewer() throws -> Bool { - let field = GraphQLField.leaf( - name: "savedByViewer", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.savedByViewer[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Bool.mockValue - } - } - - func shareInfo(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "shareInfo", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.shareInfo[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func shareStats(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "shareStats", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.shareStats[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() + return String.mockValue } } @@ -6286,67 +12298,140 @@ extension Fields where TypeLock == Objects.Link { return String.mockValue } } -} -extension Selection where TypeLock == Never, Type == Never { - typealias Link = Selection -} + func pageType() throws -> Enums.PageType { + let field = GraphQLField.leaf( + name: "pageType", + arguments: [] + ) + select(field) -extension Objects { - struct LinkShareInfo { - let __typename: TypeName = .linkShareInfo - let description: [String: String] - let imageUrl: [String: String] - let title: [String: String] - - enum TypeName: String, Codable { - case linkShareInfo = "LinkShareInfo" - } - } -} - -extension Objects.LinkShareInfo: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "description": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "imageUrl": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "title": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) + switch response { + case let .decoding(data): + if let data = data.pageType[field.alias!] { + return data } + throw HttpError.badpayload + case .mocking: + return Enums.PageType.allCases.first! } - - description = map["description"] - imageUrl = map["imageUrl"] - title = map["title"] } -} -extension Fields where TypeLock == Objects.LinkShareInfo { - func description() throws -> String { + func contentReader() throws -> Enums.ContentReader { + let field = GraphQLField.leaf( + name: "contentReader", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.contentReader[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Enums.ContentReader.allCases.first! + } + } + + func createdAt() throws -> DateTime { + let field = GraphQLField.leaf( + name: "createdAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.createdAt[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return DateTime.mockValue + } + } + + func isArchived() throws -> Bool { + let field = GraphQLField.leaf( + name: "isArchived", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.isArchived[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Bool.mockValue + } + } + + func readingProgressPercent() throws -> Double? { + let field = GraphQLField.leaf( + name: "readingProgressPercent", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.readingProgressPercent[field.alias!] + case .mocking: + return nil + } + } + + func readingProgressAnchorIndex() throws -> Int? { + let field = GraphQLField.leaf( + name: "readingProgressAnchorIndex", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.readingProgressAnchorIndex[field.alias!] + case .mocking: + return nil + } + } + + func author() throws -> String? { + let field = GraphQLField.leaf( + name: "author", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.author[field.alias!] + case .mocking: + return nil + } + } + + func image() throws -> String? { + let field = GraphQLField.leaf( + name: "image", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.image[field.alias!] + case .mocking: + return nil + } + } + + func description() throws -> String? { let field = GraphQLField.leaf( name: "description", arguments: [] @@ -6355,166 +12440,135 @@ extension Fields where TypeLock == Objects.LinkShareInfo { switch response { case let .decoding(data): - if let data = data.description[field.alias!] { - return data - } - throw HttpError.badpayload + return data.description[field.alias!] case .mocking: - return String.mockValue + return nil } } - func imageUrl() throws -> String { + func publishedAt() throws -> DateTime? { let field = GraphQLField.leaf( - name: "imageUrl", + name: "publishedAt", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.imageUrl[field.alias!] { - return data - } - throw HttpError.badpayload + return data.publishedAt[field.alias!] case .mocking: - return String.mockValue + return nil } } - func title() throws -> String { + func ownedByViewer() throws -> Bool? { let field = GraphQLField.leaf( - name: "title", + name: "ownedByViewer", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.title[field.alias!] { - return data - } - throw HttpError.badpayload + return data.ownedByViewer[field.alias!] case .mocking: - return String.mockValue + return nil } } -} -extension Selection where TypeLock == Never, Type == Never { - typealias LinkShareInfo = Selection -} - -extension Objects { - struct LoginError { - let __typename: TypeName = .loginError - let errorCodes: [String: [Enums.LoginErrorCode]] - - enum TypeName: String, Codable { - case loginError = "LoginError" - } - } -} - -extension Objects.LoginError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.LoginErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.LoginError { - func errorCodes() throws -> [Enums.LoginErrorCode] { + func originalArticleUrl() throws -> String? { let field = GraphQLField.leaf( - name: "errorCodes", + name: "originalArticleUrl", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload + return data.originalArticleUrl[field.alias!] case .mocking: - return [] + return nil } } -} -extension Selection where TypeLock == Never, Type == Never { - typealias LoginError = Selection -} + func uploadFileId() throws -> String? { + let field = GraphQLField.leaf( + name: "uploadFileId", + arguments: [] + ) + select(field) -extension Objects { - struct LoginSuccess { - let __typename: TypeName = .loginSuccess - let me: [String: Objects.User] - - enum TypeName: String, Codable { - case loginSuccess = "LoginSuccess" + switch response { + case let .decoding(data): + return data.uploadFileId[field.alias!] + case .mocking: + return nil } } -} -extension Objects.LoginSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + func pageId() throws -> String? { + let field = GraphQLField.leaf( + name: "pageId", + arguments: [] + ) + select(field) - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "me": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } + switch response { + case let .decoding(data): + return data.pageId[field.alias!] + case .mocking: + return nil } - - me = map["me"] } -} -extension Fields where TypeLock == Objects.LoginSuccess { - func me(selection: Selection) throws -> Type { + func shortId() throws -> String? { + let field = GraphQLField.leaf( + name: "shortId", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.shortId[field.alias!] + case .mocking: + return nil + } + } + + func quote() throws -> String? { + let field = GraphQLField.leaf( + name: "quote", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.quote[field.alias!] + case .mocking: + return nil + } + } + + func annotation() throws -> String? { + let field = GraphQLField.leaf( + name: "annotation", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.annotation[field.alias!] + case .mocking: + return nil + } + } + + func labels(selection: Selection) throws -> Type { let field = GraphQLField.composite( - name: "me", + name: "labels", arguments: [], selection: selection.selection ) @@ -6522,7 +12576,184 @@ extension Fields where TypeLock == Objects.LoginSuccess { switch response { case let .decoding(data): - if let data = data.me[field.alias!] { + return try selection.decode(data: data.labels[field.alias!]) + case .mocking: + return selection.mock() + } + } + + func subscription() throws -> String? { + let field = GraphQLField.leaf( + name: "subscription", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.subscription[field.alias!] + case .mocking: + return nil + } + } + + func unsubMailTo() throws -> String? { + let field = GraphQLField.leaf( + name: "unsubMailTo", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.unsubMailTo[field.alias!] + case .mocking: + return nil + } + } + + func unsubHttpUrl() throws -> String? { + let field = GraphQLField.leaf( + name: "unsubHttpUrl", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.unsubHttpUrl[field.alias!] + case .mocking: + return nil + } + } + + func state() throws -> Enums.ArticleSavingRequestStatus? { + let field = GraphQLField.leaf( + name: "state", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.state[field.alias!] + case .mocking: + return nil + } + } + + func siteName() throws -> String? { + let field = GraphQLField.leaf( + name: "siteName", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.siteName[field.alias!] + case .mocking: + return nil + } + } + + func language() throws -> String? { + let field = GraphQLField.leaf( + name: "language", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.language[field.alias!] + case .mocking: + return nil + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SearchItem = Selection +} + +extension Objects { + struct SearchItemEdge { + let __typename: TypeName = .searchItemEdge + let cursor: [String: String] + let node: [String: Objects.SearchItem] + + enum TypeName: String, Codable { + case searchItemEdge = "SearchItemEdge" + } + } +} + +extension Objects.SearchItemEdge: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "cursor": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "node": + if let value = try container.decode(Objects.SearchItem?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + cursor = map["cursor"] + node = map["node"] + } +} + +extension Fields where TypeLock == Objects.SearchItemEdge { + func cursor() throws -> String { + let field = GraphQLField.leaf( + name: "cursor", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.cursor[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func node(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "node", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.node[field.alias!] { return try selection.decode(data: data) } throw HttpError.badpayload @@ -6533,21 +12764,112 @@ extension Fields where TypeLock == Objects.LoginSuccess { } extension Selection where TypeLock == Never, Type == Never { - typealias LoginSuccess = Selection + typealias SearchItemEdge = Selection } extension Objects { - struct LogOutError { - let __typename: TypeName = .logOutError - let errorCodes: [String: [Enums.LogOutErrorCode]] + struct SearchSuccess { + let __typename: TypeName = .searchSuccess + let edges: [String: [Objects.SearchItemEdge]] + let pageInfo: [String: Objects.PageInfo] enum TypeName: String, Codable { - case logOutError = "LogOutError" + case searchSuccess = "SearchSuccess" } } } -extension Objects.LogOutError: Decodable { +extension Objects.SearchSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "edges": + if let value = try container.decode([Objects.SearchItemEdge]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "pageInfo": + if let value = try container.decode(Objects.PageInfo?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + edges = map["edges"] + pageInfo = map["pageInfo"] + } +} + +extension Fields where TypeLock == Objects.SearchSuccess { + func edges(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "edges", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.edges[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func pageInfo(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "pageInfo", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.pageInfo[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SearchSuccess = Selection +} + +extension Objects { + struct SearchError { + let __typename: TypeName = .searchError + let errorCodes: [String: [Enums.SearchErrorCode]] + + enum TypeName: String, Codable { + case searchError = "SearchError" + } + } +} + +extension Objects.SearchError: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -6560,7 +12882,7 @@ extension Objects.LogOutError: Decodable { switch field { case "errorCodes": - if let value = try container.decode([Enums.LogOutErrorCode]?.self, forKey: codingKey) { + if let value = try container.decode([Enums.SearchErrorCode]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } default: @@ -6577,8 +12899,8 @@ extension Objects.LogOutError: Decodable { } } -extension Fields where TypeLock == Objects.LogOutError { - func errorCodes() throws -> [Enums.LogOutErrorCode] { +extension Fields where TypeLock == Objects.SearchError { + func errorCodes() throws -> [Enums.SearchErrorCode] { let field = GraphQLField.leaf( name: "errorCodes", arguments: [] @@ -6598,21 +12920,21 @@ extension Fields where TypeLock == Objects.LogOutError { } extension Selection where TypeLock == Never, Type == Never { - typealias LogOutError = Selection + typealias SearchError = Selection } extension Objects { - struct LogOutSuccess { - let __typename: TypeName = .logOutSuccess - let message: [String: String] + struct SubscriptionsSuccess { + let __typename: TypeName = .subscriptionsSuccess + let subscriptions: [String: [Objects.Subscription]] enum TypeName: String, Codable { - case logOutSuccess = "LogOutSuccess" + case subscriptionsSuccess = "SubscriptionsSuccess" } } } -extension Objects.LogOutSuccess: Decodable { +extension Objects.SubscriptionsSuccess: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -6624,7 +12946,118 @@ extension Objects.LogOutSuccess: Decodable { let field = GraphQLField.getFieldNameFromAlias(alias) switch field { - case "message": + case "subscriptions": + if let value = try container.decode([Objects.Subscription]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + subscriptions = map["subscriptions"] + } +} + +extension Fields where TypeLock == Objects.SubscriptionsSuccess { + func subscriptions(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "subscriptions", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.subscriptions[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SubscriptionsSuccess = Selection +} + +extension Objects { + struct Subscription { + let __typename: TypeName = .subscription + let createdAt: [String: DateTime] + let description: [String: String] + let id: [String: String] + let name: [String: String] + let newsletterEmail: [String: String] + let status: [String: Enums.SubscriptionStatus] + let unsubscribeHttpUrl: [String: String] + let unsubscribeMailTo: [String: String] + let updatedAt: [String: DateTime] + let url: [String: String] + + enum TypeName: String, Codable { + case subscription = "Subscription" + } + } +} + +extension Objects.Subscription: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "createdAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "description": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "id": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "name": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "newsletterEmail": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "status": + if let value = try container.decode(Enums.SubscriptionStatus?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "unsubscribeHttpUrl": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "unsubscribeMailTo": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "updatedAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "url": if let value = try container.decode(String?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } @@ -6638,43 +13071,205 @@ extension Objects.LogOutSuccess: Decodable { } } - message = map["message"] + createdAt = map["createdAt"] + description = map["description"] + id = map["id"] + name = map["name"] + newsletterEmail = map["newsletterEmail"] + status = map["status"] + unsubscribeHttpUrl = map["unsubscribeHttpUrl"] + unsubscribeMailTo = map["unsubscribeMailTo"] + updatedAt = map["updatedAt"] + url = map["url"] } } -extension Fields where TypeLock == Objects.LogOutSuccess { - func message() throws -> String? { +extension Fields where TypeLock == Objects.Subscription { + func id() throws -> String { let field = GraphQLField.leaf( - name: "message", + name: "id", arguments: [] ) select(field) switch response { case let .decoding(data): - return data.message[field.alias!] + if let data = data.id[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func name() throws -> String { + let field = GraphQLField.leaf( + name: "name", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.name[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func newsletterEmail() throws -> String { + let field = GraphQLField.leaf( + name: "newsletterEmail", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.newsletterEmail[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } + + func url() throws -> String? { + let field = GraphQLField.leaf( + name: "url", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.url[field.alias!] case .mocking: return nil } } + + func description() throws -> String? { + let field = GraphQLField.leaf( + name: "description", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.description[field.alias!] + case .mocking: + return nil + } + } + + func status() throws -> Enums.SubscriptionStatus { + let field = GraphQLField.leaf( + name: "status", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.status[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Enums.SubscriptionStatus.allCases.first! + } + } + + func unsubscribeMailTo() throws -> String? { + let field = GraphQLField.leaf( + name: "unsubscribeMailTo", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.unsubscribeMailTo[field.alias!] + case .mocking: + return nil + } + } + + func unsubscribeHttpUrl() throws -> String? { + let field = GraphQLField.leaf( + name: "unsubscribeHttpUrl", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.unsubscribeHttpUrl[field.alias!] + case .mocking: + return nil + } + } + + func createdAt() throws -> DateTime { + let field = GraphQLField.leaf( + name: "createdAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.createdAt[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return DateTime.mockValue + } + } + + func updatedAt() throws -> DateTime { + let field = GraphQLField.leaf( + name: "updatedAt", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.updatedAt[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return DateTime.mockValue + } + } } extension Selection where TypeLock == Never, Type == Never { - typealias LogOutSuccess = Selection + typealias Subscription = Selection } extension Objects { - struct MergeHighlightError { - let __typename: TypeName = .mergeHighlightError - let errorCodes: [String: [Enums.MergeHighlightErrorCode]] + struct SubscriptionsError { + let __typename: TypeName = .subscriptionsError + let errorCodes: [String: [Enums.SubscriptionsErrorCode]] enum TypeName: String, Codable { - case mergeHighlightError = "MergeHighlightError" + case subscriptionsError = "SubscriptionsError" } } } -extension Objects.MergeHighlightError: Decodable { +extension Objects.SubscriptionsError: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -6687,7 +13282,7 @@ extension Objects.MergeHighlightError: Decodable { switch field { case "errorCodes": - if let value = try container.decode([Enums.MergeHighlightErrorCode]?.self, forKey: codingKey) { + if let value = try container.decode([Enums.SubscriptionsErrorCode]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } default: @@ -6704,8 +13299,8 @@ extension Objects.MergeHighlightError: Decodable { } } -extension Fields where TypeLock == Objects.MergeHighlightError { - func errorCodes() throws -> [Enums.MergeHighlightErrorCode] { +extension Fields where TypeLock == Objects.SubscriptionsError { + func errorCodes() throws -> [Enums.SubscriptionsErrorCode] { let field = GraphQLField.leaf( name: "errorCodes", arguments: [] @@ -6725,22 +13320,21 @@ extension Fields where TypeLock == Objects.MergeHighlightError { } extension Selection where TypeLock == Never, Type == Never { - typealias MergeHighlightError = Selection + typealias SubscriptionsError = Selection } extension Objects { - struct MergeHighlightSuccess { - let __typename: TypeName = .mergeHighlightSuccess - let highlight: [String: Objects.Highlight] - let overlapHighlightIdList: [String: [String]] + struct UnsubscribeSuccess { + let __typename: TypeName = .unsubscribeSuccess + let subscription: [String: Objects.Subscription] enum TypeName: String, Codable { - case mergeHighlightSuccess = "MergeHighlightSuccess" + case unsubscribeSuccess = "UnsubscribeSuccess" } } } -extension Objects.MergeHighlightSuccess: Decodable { +extension Objects.UnsubscribeSuccess: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -6752,12 +13346,8 @@ extension Objects.MergeHighlightSuccess: Decodable { let field = GraphQLField.getFieldNameFromAlias(alias) switch field { - case "highlight": - if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "overlapHighlightIdList": - if let value = try container.decode([String]?.self, forKey: codingKey) { + case "subscription": + if let value = try container.decode(Objects.Subscription?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } default: @@ -6770,15 +13360,14 @@ extension Objects.MergeHighlightSuccess: Decodable { } } - highlight = map["highlight"] - overlapHighlightIdList = map["overlapHighlightIdList"] + subscription = map["subscription"] } } -extension Fields where TypeLock == Objects.MergeHighlightSuccess { - func highlight(selection: Selection) throws -> Type { +extension Fields where TypeLock == Objects.UnsubscribeSuccess { + func subscription(selection: Selection) throws -> Type { let field = GraphQLField.composite( - name: "highlight", + name: "subscription", arguments: [], selection: selection.selection ) @@ -6786,7 +13375,7 @@ extension Fields where TypeLock == Objects.MergeHighlightSuccess { switch response { case let .decoding(data): - if let data = data.highlight[field.alias!] { + if let data = data.subscription[field.alias!] { return try selection.decode(data: data) } throw HttpError.badpayload @@ -6794,17 +13383,64 @@ extension Fields where TypeLock == Objects.MergeHighlightSuccess { return selection.mock() } } +} - func overlapHighlightIdList() throws -> [String] { +extension Selection where TypeLock == Never, Type == Never { + typealias UnsubscribeSuccess = Selection +} + +extension Objects { + struct UnsubscribeError { + let __typename: TypeName = .unsubscribeError + let errorCodes: [String: [Enums.UnsubscribeErrorCode]] + + enum TypeName: String, Codable { + case unsubscribeError = "UnsubscribeError" + } + } +} + +extension Objects.UnsubscribeError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UnsubscribeErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.UnsubscribeError { + func errorCodes() throws -> [Enums.UnsubscribeErrorCode] { let field = GraphQLField.leaf( - name: "overlapHighlightIdList", + name: "errorCodes", arguments: [] ) select(field) switch response { case let .decoding(data): - if let data = data.overlapHighlightIdList[field.alias!] { + if let data = data.errorCodes[field.alias!] { return data } throw HttpError.badpayload @@ -6815,7 +13451,268 @@ extension Fields where TypeLock == Objects.MergeHighlightSuccess { } extension Selection where TypeLock == Never, Type == Never { - typealias MergeHighlightSuccess = Selection + typealias UnsubscribeError = Selection +} + +extension Objects { + struct SubscribeSuccess { + let __typename: TypeName = .subscribeSuccess + let subscriptions: [String: [Objects.Subscription]] + + enum TypeName: String, Codable { + case subscribeSuccess = "SubscribeSuccess" + } + } +} + +extension Objects.SubscribeSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "subscriptions": + if let value = try container.decode([Objects.Subscription]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + subscriptions = map["subscriptions"] + } +} + +extension Fields where TypeLock == Objects.SubscribeSuccess { + func subscriptions(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "subscriptions", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.subscriptions[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SubscribeSuccess = Selection +} + +extension Objects { + struct SubscribeError { + let __typename: TypeName = .subscribeError + let errorCodes: [String: [Enums.SubscribeErrorCode]] + + enum TypeName: String, Codable { + case subscribeError = "SubscribeError" + } + } +} + +extension Objects.SubscribeError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SubscribeErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.SubscribeError { + func errorCodes() throws -> [Enums.SubscribeErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SubscribeError = Selection +} + +extension Objects { + struct AddPopularReadSuccess { + let __typename: TypeName = .addPopularReadSuccess + let pageId: [String: String] + + enum TypeName: String, Codable { + case addPopularReadSuccess = "AddPopularReadSuccess" + } + } +} + +extension Objects.AddPopularReadSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "pageId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + pageId = map["pageId"] + } +} + +extension Fields where TypeLock == Objects.AddPopularReadSuccess { + func pageId() throws -> String { + let field = GraphQLField.leaf( + name: "pageId", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.pageId[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return String.mockValue + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias AddPopularReadSuccess = Selection +} + +extension Objects { + struct AddPopularReadError { + let __typename: TypeName = .addPopularReadError + let errorCodes: [String: [Enums.AddPopularReadErrorCode]] + + enum TypeName: String, Codable { + case addPopularReadError = "AddPopularReadError" + } + } +} + +extension Objects.AddPopularReadError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.AddPopularReadErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Objects.AddPopularReadError { + func errorCodes() throws -> [Enums.AddPopularReadErrorCode] { + let field = GraphQLField.leaf( + name: "errorCodes", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.errorCodes[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias AddPopularReadError = Selection } extension Objects { @@ -7136,310 +14033,6 @@ extension Objects.Mutation: Decodable { } extension Fields where TypeLock == Objects.Mutation { - func addPopularRead(name: String, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "addPopularRead", - arguments: [Argument(name: "name", type: "String!", value: name)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.addPopularRead[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func createArticle(input: InputObjects.CreateArticleInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "createArticle", - arguments: [Argument(name: "input", type: "CreateArticleInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.createArticle[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func createArticleSavingRequest(input: InputObjects.CreateArticleSavingRequestInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "createArticleSavingRequest", - arguments: [Argument(name: "input", type: "CreateArticleSavingRequestInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.createArticleSavingRequest[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func createHighlight(input: InputObjects.CreateHighlightInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "createHighlight", - arguments: [Argument(name: "input", type: "CreateHighlightInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.createHighlight[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func createHighlightReply(input: InputObjects.CreateHighlightReplyInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "createHighlightReply", - arguments: [Argument(name: "input", type: "CreateHighlightReplyInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.createHighlightReply[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func createLabel(input: InputObjects.CreateLabelInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "createLabel", - arguments: [Argument(name: "input", type: "CreateLabelInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.createLabel[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func createNewsletterEmail(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "createNewsletterEmail", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.createNewsletterEmail[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func createReaction(input: InputObjects.CreateReactionInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "createReaction", - arguments: [Argument(name: "input", type: "CreateReactionInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.createReaction[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func createReminder(input: InputObjects.CreateReminderInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "createReminder", - arguments: [Argument(name: "input", type: "CreateReminderInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.createReminder[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func deleteHighlight(highlightId: String, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "deleteHighlight", - arguments: [Argument(name: "highlightId", type: "ID!", value: highlightId)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.deleteHighlight[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func deleteHighlightReply(highlightReplyId: String, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "deleteHighlightReply", - arguments: [Argument(name: "highlightReplyId", type: "ID!", value: highlightReplyId)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.deleteHighlightReply[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func deleteLabel(id: String, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "deleteLabel", - arguments: [Argument(name: "id", type: "ID!", value: id)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.deleteLabel[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func deleteNewsletterEmail(newsletterEmailId: String, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "deleteNewsletterEmail", - arguments: [Argument(name: "newsletterEmailId", type: "ID!", value: newsletterEmailId)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.deleteNewsletterEmail[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func deleteReaction(id: String, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "deleteReaction", - arguments: [Argument(name: "id", type: "ID!", value: id)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.deleteReaction[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func deleteReminder(id: String, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "deleteReminder", - arguments: [Argument(name: "id", type: "ID!", value: id)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.deleteReminder[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func generateApiKey(input: InputObjects.GenerateApiKeyInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "generateApiKey", - arguments: [Argument(name: "input", type: "GenerateApiKeyInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.generateApiKey[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - func googleLogin(input: InputObjects.GoogleLoginInput, selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "googleLogin", @@ -7478,25 +14071,6 @@ extension Fields where TypeLock == Objects.Mutation { } } - func login(input: InputObjects.LoginInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "login", - arguments: [Argument(name: "input", type: "LoginInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.login[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - func logOut(selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "logOut", @@ -7516,462 +14090,6 @@ extension Fields where TypeLock == Objects.Mutation { } } - func mergeHighlight(input: InputObjects.MergeHighlightInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "mergeHighlight", - arguments: [Argument(name: "input", type: "MergeHighlightInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.mergeHighlight[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func reportItem(input: InputObjects.ReportItemInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "reportItem", - arguments: [Argument(name: "input", type: "ReportItemInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.reportItem[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func saveArticleReadingProgress(input: InputObjects.SaveArticleReadingProgressInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "saveArticleReadingProgress", - arguments: [Argument(name: "input", type: "SaveArticleReadingProgressInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.saveArticleReadingProgress[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func saveFile(input: InputObjects.SaveFileInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "saveFile", - arguments: [Argument(name: "input", type: "SaveFileInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.saveFile[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func savePage(input: InputObjects.SavePageInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "savePage", - arguments: [Argument(name: "input", type: "SavePageInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.savePage[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func saveUrl(input: InputObjects.SaveUrlInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "saveUrl", - arguments: [Argument(name: "input", type: "SaveUrlInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.saveUrl[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func setBookmarkArticle(input: InputObjects.SetBookmarkArticleInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "setBookmarkArticle", - arguments: [Argument(name: "input", type: "SetBookmarkArticleInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.setBookmarkArticle[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func setDeviceToken(input: InputObjects.SetDeviceTokenInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "setDeviceToken", - arguments: [Argument(name: "input", type: "SetDeviceTokenInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.setDeviceToken[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func setFollow(input: InputObjects.SetFollowInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "setFollow", - arguments: [Argument(name: "input", type: "SetFollowInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.setFollow[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func setLabels(input: InputObjects.SetLabelsInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "setLabels", - arguments: [Argument(name: "input", type: "SetLabelsInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.setLabels[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func setLinkArchived(input: InputObjects.ArchiveLinkInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "setLinkArchived", - arguments: [Argument(name: "input", type: "ArchiveLinkInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.setLinkArchived[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func setShareArticle(input: InputObjects.SetShareArticleInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "setShareArticle", - arguments: [Argument(name: "input", type: "SetShareArticleInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.setShareArticle[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func setShareHighlight(input: InputObjects.SetShareHighlightInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "setShareHighlight", - arguments: [Argument(name: "input", type: "SetShareHighlightInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.setShareHighlight[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func setUserPersonalization(input: InputObjects.SetUserPersonalizationInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "setUserPersonalization", - arguments: [Argument(name: "input", type: "SetUserPersonalizationInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.setUserPersonalization[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func signup(input: InputObjects.SignupInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "signup", - arguments: [Argument(name: "input", type: "SignupInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.signup[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func subscribe(name: String, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "subscribe", - arguments: [Argument(name: "name", type: "String!", value: name)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.subscribe[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func unsubscribe(name: String, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "unsubscribe", - arguments: [Argument(name: "name", type: "String!", value: name)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.unsubscribe[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func updateHighlight(input: InputObjects.UpdateHighlightInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "updateHighlight", - arguments: [Argument(name: "input", type: "UpdateHighlightInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.updateHighlight[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func updateHighlightReply(input: InputObjects.UpdateHighlightReplyInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "updateHighlightReply", - arguments: [Argument(name: "input", type: "UpdateHighlightReplyInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.updateHighlightReply[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func updateLabel(input: InputObjects.UpdateLabelInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "updateLabel", - arguments: [Argument(name: "input", type: "UpdateLabelInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.updateLabel[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func updateLinkShareInfo(input: InputObjects.UpdateLinkShareInfoInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "updateLinkShareInfo", - arguments: [Argument(name: "input", type: "UpdateLinkShareInfoInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.updateLinkShareInfo[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func updatePage(input: InputObjects.UpdatePageInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "updatePage", - arguments: [Argument(name: "input", type: "UpdatePageInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.updatePage[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func updateReminder(input: InputObjects.UpdateReminderInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "updateReminder", - arguments: [Argument(name: "input", type: "UpdateReminderInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.updateReminder[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func updateSharedComment(input: InputObjects.UpdateSharedCommentInput, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "updateSharedComment", - arguments: [Argument(name: "input", type: "UpdateSharedCommentInput!", value: input)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.updateSharedComment[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - func updateUser(input: InputObjects.UpdateUserInput, selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "updateUser", @@ -8010,6 +14128,196 @@ extension Fields where TypeLock == Objects.Mutation { } } + func createArticle(input: InputObjects.CreateArticleInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "createArticle", + arguments: [Argument(name: "input", type: "CreateArticleInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.createArticle[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func createHighlight(input: InputObjects.CreateHighlightInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "createHighlight", + arguments: [Argument(name: "input", type: "CreateHighlightInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.createHighlight[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func mergeHighlight(input: InputObjects.MergeHighlightInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "mergeHighlight", + arguments: [Argument(name: "input", type: "MergeHighlightInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.mergeHighlight[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func updateHighlight(input: InputObjects.UpdateHighlightInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "updateHighlight", + arguments: [Argument(name: "input", type: "UpdateHighlightInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.updateHighlight[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func deleteHighlight(highlightId: String, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "deleteHighlight", + arguments: [Argument(name: "highlightId", type: "ID!", value: highlightId)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.deleteHighlight[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func createHighlightReply(input: InputObjects.CreateHighlightReplyInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "createHighlightReply", + arguments: [Argument(name: "input", type: "CreateHighlightReplyInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.createHighlightReply[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func updateHighlightReply(input: InputObjects.UpdateHighlightReplyInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "updateHighlightReply", + arguments: [Argument(name: "input", type: "UpdateHighlightReplyInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.updateHighlightReply[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func deleteHighlightReply(highlightReplyId: String, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "deleteHighlightReply", + arguments: [Argument(name: "highlightReplyId", type: "ID!", value: highlightReplyId)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.deleteHighlightReply[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func createReaction(input: InputObjects.CreateReactionInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "createReaction", + arguments: [Argument(name: "input", type: "CreateReactionInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.createReaction[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func deleteReaction(id: String, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "deleteReaction", + arguments: [Argument(name: "id", type: "ID!", value: id)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.deleteReaction[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + func uploadFileRequest(input: InputObjects.UploadFileRequestInput, selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "uploadFileRequest", @@ -8028,232 +14336,219 @@ extension Fields where TypeLock == Objects.Mutation { return selection.mock() } } -} -extension Selection where TypeLock == Never, Type == Never { - typealias Mutation = Selection -} - -extension Objects { - struct NewsletterEmail { - let __typename: TypeName = .newsletterEmail - let address: [String: String] - let confirmationCode: [String: String] - let id: [String: String] - - enum TypeName: String, Codable { - case newsletterEmail = "NewsletterEmail" - } - } -} - -extension Objects.NewsletterEmail: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "address": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "confirmationCode": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "id": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - address = map["address"] - confirmationCode = map["confirmationCode"] - id = map["id"] - } -} - -extension Fields where TypeLock == Objects.NewsletterEmail { - func address() throws -> String { - let field = GraphQLField.leaf( - name: "address", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.address[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func confirmationCode() throws -> String? { - let field = GraphQLField.leaf( - name: "confirmationCode", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.confirmationCode[field.alias!] - case .mocking: - return nil - } - } - - func id() throws -> String { - let field = GraphQLField.leaf( - name: "id", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.id[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias NewsletterEmail = Selection -} - -extension Objects { - struct NewsletterEmailsError { - let __typename: TypeName = .newsletterEmailsError - let errorCodes: [String: [Enums.NewsletterEmailsErrorCode]] - - enum TypeName: String, Codable { - case newsletterEmailsError = "NewsletterEmailsError" - } - } -} - -extension Objects.NewsletterEmailsError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.NewsletterEmailsErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.NewsletterEmailsError { - func errorCodes() throws -> [Enums.NewsletterEmailsErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias NewsletterEmailsError = Selection -} - -extension Objects { - struct NewsletterEmailsSuccess { - let __typename: TypeName = .newsletterEmailsSuccess - let newsletterEmails: [String: [Objects.NewsletterEmail]] - - enum TypeName: String, Codable { - case newsletterEmailsSuccess = "NewsletterEmailsSuccess" - } - } -} - -extension Objects.NewsletterEmailsSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "newsletterEmails": - if let value = try container.decode([Objects.NewsletterEmail]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - newsletterEmails = map["newsletterEmails"] - } -} - -extension Fields where TypeLock == Objects.NewsletterEmailsSuccess { - func newsletterEmails(selection: Selection) throws -> Type { + func saveArticleReadingProgress(input: InputObjects.SaveArticleReadingProgressInput, selection: Selection) throws -> Type { let field = GraphQLField.composite( - name: "newsletterEmails", + name: "saveArticleReadingProgress", + arguments: [Argument(name: "input", type: "SaveArticleReadingProgressInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.saveArticleReadingProgress[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func setShareArticle(input: InputObjects.SetShareArticleInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "setShareArticle", + arguments: [Argument(name: "input", type: "SetShareArticleInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.setShareArticle[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func updateSharedComment(input: InputObjects.UpdateSharedCommentInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "updateSharedComment", + arguments: [Argument(name: "input", type: "UpdateSharedCommentInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.updateSharedComment[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func setFollow(input: InputObjects.SetFollowInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "setFollow", + arguments: [Argument(name: "input", type: "SetFollowInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.setFollow[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func setBookmarkArticle(input: InputObjects.SetBookmarkArticleInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "setBookmarkArticle", + arguments: [Argument(name: "input", type: "SetBookmarkArticleInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.setBookmarkArticle[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func setUserPersonalization(input: InputObjects.SetUserPersonalizationInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "setUserPersonalization", + arguments: [Argument(name: "input", type: "SetUserPersonalizationInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.setUserPersonalization[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func createArticleSavingRequest(input: InputObjects.CreateArticleSavingRequestInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "createArticleSavingRequest", + arguments: [Argument(name: "input", type: "CreateArticleSavingRequestInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.createArticleSavingRequest[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func setShareHighlight(input: InputObjects.SetShareHighlightInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "setShareHighlight", + arguments: [Argument(name: "input", type: "SetShareHighlightInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.setShareHighlight[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func reportItem(input: InputObjects.ReportItemInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "reportItem", + arguments: [Argument(name: "input", type: "ReportItemInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.reportItem[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func updateLinkShareInfo(input: InputObjects.UpdateLinkShareInfoInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "updateLinkShareInfo", + arguments: [Argument(name: "input", type: "UpdateLinkShareInfoInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.updateLinkShareInfo[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func setLinkArchived(input: InputObjects.ArchiveLinkInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "setLinkArchived", + arguments: [Argument(name: "input", type: "ArchiveLinkInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.setLinkArchived[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func createNewsletterEmail(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "createNewsletterEmail", arguments: [], selection: selection.selection ) @@ -8261,7 +14556,368 @@ extension Fields where TypeLock == Objects.NewsletterEmailsSuccess { switch response { case let .decoding(data): - if let data = data.newsletterEmails[field.alias!] { + if let data = data.createNewsletterEmail[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func deleteNewsletterEmail(newsletterEmailId: String, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "deleteNewsletterEmail", + arguments: [Argument(name: "newsletterEmailId", type: "ID!", value: newsletterEmailId)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.deleteNewsletterEmail[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func saveUrl(input: InputObjects.SaveUrlInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "saveUrl", + arguments: [Argument(name: "input", type: "SaveUrlInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.saveUrl[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func savePage(input: InputObjects.SavePageInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "savePage", + arguments: [Argument(name: "input", type: "SavePageInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.savePage[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func updatePage(input: InputObjects.UpdatePageInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "updatePage", + arguments: [Argument(name: "input", type: "UpdatePageInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.updatePage[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func saveFile(input: InputObjects.SaveFileInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "saveFile", + arguments: [Argument(name: "input", type: "SaveFileInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.saveFile[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func createReminder(input: InputObjects.CreateReminderInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "createReminder", + arguments: [Argument(name: "input", type: "CreateReminderInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.createReminder[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func updateReminder(input: InputObjects.UpdateReminderInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "updateReminder", + arguments: [Argument(name: "input", type: "UpdateReminderInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.updateReminder[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func deleteReminder(id: String, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "deleteReminder", + arguments: [Argument(name: "id", type: "ID!", value: id)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.deleteReminder[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func setDeviceToken(input: InputObjects.SetDeviceTokenInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "setDeviceToken", + arguments: [Argument(name: "input", type: "SetDeviceTokenInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.setDeviceToken[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func createLabel(input: InputObjects.CreateLabelInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "createLabel", + arguments: [Argument(name: "input", type: "CreateLabelInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.createLabel[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func updateLabel(input: InputObjects.UpdateLabelInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "updateLabel", + arguments: [Argument(name: "input", type: "UpdateLabelInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.updateLabel[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func deleteLabel(id: String, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "deleteLabel", + arguments: [Argument(name: "id", type: "ID!", value: id)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.deleteLabel[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func login(input: InputObjects.LoginInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "login", + arguments: [Argument(name: "input", type: "LoginInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.login[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func signup(input: InputObjects.SignupInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "signup", + arguments: [Argument(name: "input", type: "SignupInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.signup[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func setLabels(input: InputObjects.SetLabelsInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "setLabels", + arguments: [Argument(name: "input", type: "SetLabelsInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.setLabels[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func generateApiKey(input: InputObjects.GenerateApiKeyInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "generateApiKey", + arguments: [Argument(name: "input", type: "GenerateApiKeyInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.generateApiKey[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func unsubscribe(name: String, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "unsubscribe", + arguments: [Argument(name: "name", type: "String!", value: name)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.unsubscribe[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func subscribe(name: String, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "subscribe", + arguments: [Argument(name: "name", type: "String!", value: name)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.subscribe[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func addPopularRead(name: String, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "addPopularRead", + arguments: [Argument(name: "name", type: "String!", value: name)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.addPopularRead[field.alias!] { return try selection.decode(data: data) } throw HttpError.badpayload @@ -8272,664 +14928,7 @@ extension Fields where TypeLock == Objects.NewsletterEmailsSuccess { } extension Selection where TypeLock == Never, Type == Never { - typealias NewsletterEmailsSuccess = Selection -} - -extension Objects { - struct Page { - let __typename: TypeName = .page - let author: [String: String] - let createdAt: [String: DateTime] - let description: [String: String] - let hash: [String: String] - let id: [String: String] - let image: [String: String] - let originalHtml: [String: String] - let originalUrl: [String: String] - let publishedAt: [String: DateTime] - let readableHtml: [String: String] - let title: [String: String] - let type: [String: Enums.PageType] - let url: [String: String] - - enum TypeName: String, Codable { - case page = "Page" - } - } -} - -extension Objects.Page: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "author": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "createdAt": - if let value = try container.decode(DateTime?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "description": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "hash": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "id": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "image": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "originalHtml": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "originalUrl": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "publishedAt": - if let value = try container.decode(DateTime?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "readableHtml": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "title": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "type": - if let value = try container.decode(Enums.PageType?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "url": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - author = map["author"] - createdAt = map["createdAt"] - description = map["description"] - hash = map["hash"] - id = map["id"] - image = map["image"] - originalHtml = map["originalHtml"] - originalUrl = map["originalUrl"] - publishedAt = map["publishedAt"] - readableHtml = map["readableHtml"] - title = map["title"] - type = map["type"] - url = map["url"] - } -} - -extension Fields where TypeLock == Objects.Page { - func author() throws -> String { - let field = GraphQLField.leaf( - name: "author", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.author[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func createdAt() throws -> DateTime { - let field = GraphQLField.leaf( - name: "createdAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.createdAt[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return DateTime.mockValue - } - } - - func description() throws -> String { - let field = GraphQLField.leaf( - name: "description", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.description[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func hash() throws -> String { - let field = GraphQLField.leaf( - name: "hash", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.hash[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func id() throws -> String { - let field = GraphQLField.leaf( - name: "id", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.id[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func image() throws -> String { - let field = GraphQLField.leaf( - name: "image", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.image[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func originalHtml() throws -> String { - let field = GraphQLField.leaf( - name: "originalHtml", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.originalHtml[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func originalUrl() throws -> String { - let field = GraphQLField.leaf( - name: "originalUrl", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.originalUrl[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func publishedAt() throws -> DateTime? { - let field = GraphQLField.leaf( - name: "publishedAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.publishedAt[field.alias!] - case .mocking: - return nil - } - } - - func readableHtml() throws -> String { - let field = GraphQLField.leaf( - name: "readableHtml", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.readableHtml[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func title() throws -> String { - let field = GraphQLField.leaf( - name: "title", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.title[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func type() throws -> Enums.PageType { - let field = GraphQLField.leaf( - name: "type", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.type[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Enums.PageType.allCases.first! - } - } - - func url() throws -> String { - let field = GraphQLField.leaf( - name: "url", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.url[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias Page = Selection -} - -extension Objects { - struct PageInfo { - let __typename: TypeName = .pageInfo - let endCursor: [String: String] - let hasNextPage: [String: Bool] - let hasPreviousPage: [String: Bool] - let startCursor: [String: String] - let totalCount: [String: Int] - - enum TypeName: String, Codable { - case pageInfo = "PageInfo" - } - } -} - -extension Objects.PageInfo: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "endCursor": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "hasNextPage": - if let value = try container.decode(Bool?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "hasPreviousPage": - if let value = try container.decode(Bool?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "startCursor": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "totalCount": - if let value = try container.decode(Int?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - endCursor = map["endCursor"] - hasNextPage = map["hasNextPage"] - hasPreviousPage = map["hasPreviousPage"] - startCursor = map["startCursor"] - totalCount = map["totalCount"] - } -} - -extension Fields where TypeLock == Objects.PageInfo { - func endCursor() throws -> String? { - let field = GraphQLField.leaf( - name: "endCursor", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.endCursor[field.alias!] - case .mocking: - return nil - } - } - - func hasNextPage() throws -> Bool { - let field = GraphQLField.leaf( - name: "hasNextPage", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.hasNextPage[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Bool.mockValue - } - } - - func hasPreviousPage() throws -> Bool { - let field = GraphQLField.leaf( - name: "hasPreviousPage", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.hasPreviousPage[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Bool.mockValue - } - } - - func startCursor() throws -> String? { - let field = GraphQLField.leaf( - name: "startCursor", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.startCursor[field.alias!] - case .mocking: - return nil - } - } - - func totalCount() throws -> Int? { - let field = GraphQLField.leaf( - name: "totalCount", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.totalCount[field.alias!] - case .mocking: - return nil - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias PageInfo = Selection -} - -extension Objects { - struct Profile { - let __typename: TypeName = .profile - let bio: [String: String] - let id: [String: String] - let pictureUrl: [String: String] - let `private`: [String: Bool] - let username: [String: String] - - enum TypeName: String, Codable { - case profile = "Profile" - } - } -} - -extension Objects.Profile: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "bio": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "id": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "pictureUrl": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "private": - if let value = try container.decode(Bool?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "username": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - bio = map["bio"] - id = map["id"] - pictureUrl = map["pictureUrl"] - self.private = map["private"] - username = map["username"] - } -} - -extension Fields where TypeLock == Objects.Profile { - func bio() throws -> String? { - let field = GraphQLField.leaf( - name: "bio", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.bio[field.alias!] - case .mocking: - return nil - } - } - - func id() throws -> String { - let field = GraphQLField.leaf( - name: "id", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.id[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func pictureUrl() throws -> String? { - let field = GraphQLField.leaf( - name: "pictureUrl", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.pictureUrl[field.alias!] - case .mocking: - return nil - } - } - - func `private`() throws -> Bool { - let field = GraphQLField.leaf( - name: "private", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.private[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Bool.mockValue - } - } - - func username() throws -> String { - let field = GraphQLField.leaf( - name: "username", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.username[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias Profile = Selection + typealias Mutation = Selection } extension Objects { @@ -9076,17 +15075,48 @@ extension Objects.Query: Decodable { } extension Fields where TypeLock == Objects.Query { - func article(slug: String, username: String, selection: Selection) throws -> Type { + func hello() throws -> String? { + let field = GraphQLField.leaf( + name: "hello", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.hello[field.alias!] + case .mocking: + return nil + } + } + + func me(selection: Selection) throws -> Type { let field = GraphQLField.composite( - name: "article", - arguments: [Argument(name: "slug", type: "String!", value: slug), Argument(name: "username", type: "String!", value: username)], + name: "me", + arguments: [], selection: selection.selection ) select(field) switch response { case let .decoding(data): - if let data = data.article[field.alias!] { + return try selection.decode(data: data.me[field.alias!]) + case .mocking: + return selection.mock() + } + } + + func user(userId: OptionalArgument = .absent(), username: OptionalArgument = .absent(), selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "user", + arguments: [Argument(name: "userId", type: "ID", value: userId), Argument(name: "username", type: "String", value: username)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.user[field.alias!] { return try selection.decode(data: data) } throw HttpError.badpayload @@ -9095,10 +15125,10 @@ extension Fields where TypeLock == Objects.Query { } } - func articles(after: OptionalArgument = .absent(), first: OptionalArgument = .absent(), includePending: OptionalArgument = .absent(), query: OptionalArgument = .absent(), sharedOnly: OptionalArgument = .absent(), sort: OptionalArgument = .absent(), selection: Selection) throws -> Type { + func articles(sharedOnly: OptionalArgument = .absent(), sort: OptionalArgument = .absent(), after: OptionalArgument = .absent(), first: OptionalArgument = .absent(), query: OptionalArgument = .absent(), includePending: OptionalArgument = .absent(), selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "articles", - arguments: [Argument(name: "after", type: "String", value: after), Argument(name: "first", type: "Int", value: first), Argument(name: "includePending", type: "Boolean", value: includePending), Argument(name: "query", type: "String", value: query), Argument(name: "sharedOnly", type: "Boolean", value: sharedOnly), Argument(name: "sort", type: "SortParams", value: sort)], + arguments: [Argument(name: "sharedOnly", type: "Boolean", value: sharedOnly), Argument(name: "sort", type: "SortParams", value: sort), Argument(name: "after", type: "String", value: after), Argument(name: "first", type: "Int", value: first), Argument(name: "query", type: "String", value: query), Argument(name: "includePending", type: "Boolean", value: includePending)], selection: selection.selection ) select(field) @@ -9114,17 +15144,17 @@ extension Fields where TypeLock == Objects.Query { } } - func articleSavingRequest(id: String, selection: Selection) throws -> Type { + func article(username: String, slug: String, selection: Selection) throws -> Type { let field = GraphQLField.composite( - name: "articleSavingRequest", - arguments: [Argument(name: "id", type: "ID!", value: id)], + name: "article", + arguments: [Argument(name: "username", type: "String!", value: username), Argument(name: "slug", type: "String!", value: slug)], selection: selection.selection ) select(field) switch response { case let .decoding(data): - if let data = data.articleSavingRequest[field.alias!] { + if let data = data.article[field.alias!] { return try selection.decode(data: data) } throw HttpError.badpayload @@ -9133,10 +15163,29 @@ extension Fields where TypeLock == Objects.Query { } } - func feedArticles(after: OptionalArgument = .absent(), first: OptionalArgument = .absent(), sharedByUser: OptionalArgument = .absent(), sort: OptionalArgument = .absent(), selection: Selection) throws -> Type { + func sharedArticle(username: String, slug: String, selectedHighlightId: OptionalArgument = .absent(), selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "sharedArticle", + arguments: [Argument(name: "username", type: "String!", value: username), Argument(name: "slug", type: "String!", value: slug), Argument(name: "selectedHighlightId", type: "String", value: selectedHighlightId)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.sharedArticle[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func feedArticles(after: OptionalArgument = .absent(), first: OptionalArgument = .absent(), sort: OptionalArgument = .absent(), sharedByUser: OptionalArgument = .absent(), selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "feedArticles", - arguments: [Argument(name: "after", type: "String", value: after), Argument(name: "first", type: "Int", value: first), Argument(name: "sharedByUser", type: "ID", value: sharedByUser), Argument(name: "sort", type: "SortParams", value: sort)], + arguments: [Argument(name: "after", type: "String", value: after), Argument(name: "first", type: "Int", value: first), Argument(name: "sort", type: "SortParams", value: sort), Argument(name: "sharedByUser", type: "ID", value: sharedByUser)], selection: selection.selection ) select(field) @@ -9152,6 +15201,43 @@ extension Fields where TypeLock == Objects.Query { } } + func users(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "users", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.users[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + + func validateUsername(username: String) throws -> Bool { + let field = GraphQLField.leaf( + name: "validateUsername", + arguments: [Argument(name: "username", type: "String!", value: username)] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.validateUsername[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Bool.mockValue + } + } + func getFollowers(userId: OptionalArgument = .absent(), selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "getFollowers", @@ -9209,32 +15295,17 @@ extension Fields where TypeLock == Objects.Query { } } - func hello() throws -> String? { - let field = GraphQLField.leaf( - name: "hello", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.hello[field.alias!] - case .mocking: - return nil - } - } - - func labels(selection: Selection) throws -> Type { + func articleSavingRequest(id: String, selection: Selection) throws -> Type { let field = GraphQLField.composite( - name: "labels", - arguments: [], + name: "articleSavingRequest", + arguments: [Argument(name: "id", type: "ID!", value: id)], selection: selection.selection ) select(field) switch response { case let .decoding(data): - if let data = data.labels[field.alias!] { + if let data = data.articleSavingRequest[field.alias!] { return try selection.decode(data: data) } throw HttpError.badpayload @@ -9243,22 +15314,6 @@ extension Fields where TypeLock == Objects.Query { } } - func me(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "me", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - return try selection.decode(data: data.me[field.alias!]) - case .mocking: - return selection.mock() - } - } - func newsletterEmails(selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "newsletterEmails", @@ -9297,6 +15352,25 @@ extension Fields where TypeLock == Objects.Query { } } + func labels(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "labels", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.labels[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + func search(after: OptionalArgument = .absent(), first: OptionalArgument = .absent(), query: OptionalArgument = .absent(), selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "search", @@ -9316,25 +15390,6 @@ extension Fields where TypeLock == Objects.Query { } } - func sharedArticle(selectedHighlightId: OptionalArgument = .absent(), slug: String, username: String, selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "sharedArticle", - arguments: [Argument(name: "selectedHighlightId", type: "String", value: selectedHighlightId), Argument(name: "slug", type: "String!", value: slug), Argument(name: "username", type: "String!", value: username)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.sharedArticle[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - func subscriptions(sort: OptionalArgument = .absent(), selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "subscriptions", @@ -9353,5587 +15408,33 @@ extension Fields where TypeLock == Objects.Query { return selection.mock() } } - - func user(userId: OptionalArgument = .absent(), username: OptionalArgument = .absent(), selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "user", - arguments: [Argument(name: "userId", type: "ID", value: userId), Argument(name: "username", type: "String", value: username)], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.user[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func users(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "users", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.users[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func validateUsername(username: String) throws -> Bool { - let field = GraphQLField.leaf( - name: "validateUsername", - arguments: [Argument(name: "username", type: "String!", value: username)] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.validateUsername[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Bool.mockValue - } - } } extension Selection where TypeLock == Never, Type == Never { typealias Query = Selection } -extension Objects { - struct Reaction { - let __typename: TypeName = .reaction - let code: [String: Enums.ReactionType] - let createdAt: [String: DateTime] - let id: [String: String] - let updatedAt: [String: DateTime] - let user: [String: Objects.User] +// MARK: - Interfaces - enum TypeName: String, Codable { - case reaction = "Reaction" - } - } -} +enum Interfaces {} -extension Objects.Reaction: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) +// MARK: - Unions - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "code": - if let value = try container.decode(Enums.ReactionType?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "createdAt": - if let value = try container.decode(DateTime?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "id": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "updatedAt": - if let value = try container.decode(DateTime?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "user": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - code = map["code"] - createdAt = map["createdAt"] - id = map["id"] - updatedAt = map["updatedAt"] - user = map["user"] - } -} - -extension Fields where TypeLock == Objects.Reaction { - func code() throws -> Enums.ReactionType { - let field = GraphQLField.leaf( - name: "code", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.code[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Enums.ReactionType.allCases.first! - } - } - - func createdAt() throws -> DateTime { - let field = GraphQLField.leaf( - name: "createdAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.createdAt[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return DateTime.mockValue - } - } - - func id() throws -> String { - let field = GraphQLField.leaf( - name: "id", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.id[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func updatedAt() throws -> DateTime? { - let field = GraphQLField.leaf( - name: "updatedAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.updatedAt[field.alias!] - case .mocking: - return nil - } - } - - func user(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "user", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.user[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias Reaction = Selection -} - -extension Objects { - struct ReadState { - let __typename: TypeName = .readState - let progressAnchorIndex: [String: Int] - let progressPercent: [String: Double] - let reading: [String: Bool] - let readingTime: [String: Int] - - enum TypeName: String, Codable { - case readState = "ReadState" - } - } -} - -extension Objects.ReadState: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "progressAnchorIndex": - if let value = try container.decode(Int?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "progressPercent": - if let value = try container.decode(Double?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "reading": - if let value = try container.decode(Bool?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "readingTime": - if let value = try container.decode(Int?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - progressAnchorIndex = map["progressAnchorIndex"] - progressPercent = map["progressPercent"] - reading = map["reading"] - readingTime = map["readingTime"] - } -} - -extension Fields where TypeLock == Objects.ReadState { - func progressAnchorIndex() throws -> Int { - let field = GraphQLField.leaf( - name: "progressAnchorIndex", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.progressAnchorIndex[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Int.mockValue - } - } - - func progressPercent() throws -> Double { - let field = GraphQLField.leaf( - name: "progressPercent", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.progressPercent[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Double.mockValue - } - } - - func reading() throws -> Bool? { - let field = GraphQLField.leaf( - name: "reading", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.reading[field.alias!] - case .mocking: - return nil - } - } - - func readingTime() throws -> Int? { - let field = GraphQLField.leaf( - name: "readingTime", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.readingTime[field.alias!] - case .mocking: - return nil - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias ReadState = Selection -} - -extension Objects { - struct Reminder { - let __typename: TypeName = .reminder - let archiveUntil: [String: Bool] - let id: [String: String] - let remindAt: [String: DateTime] - let sendNotification: [String: Bool] - - enum TypeName: String, Codable { - case reminder = "Reminder" - } - } -} - -extension Objects.Reminder: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "archiveUntil": - if let value = try container.decode(Bool?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "id": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "remindAt": - if let value = try container.decode(DateTime?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "sendNotification": - if let value = try container.decode(Bool?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - archiveUntil = map["archiveUntil"] - id = map["id"] - remindAt = map["remindAt"] - sendNotification = map["sendNotification"] - } -} - -extension Fields where TypeLock == Objects.Reminder { - func archiveUntil() throws -> Bool { - let field = GraphQLField.leaf( - name: "archiveUntil", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.archiveUntil[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Bool.mockValue - } - } - - func id() throws -> String { - let field = GraphQLField.leaf( - name: "id", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.id[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func remindAt() throws -> DateTime { - let field = GraphQLField.leaf( - name: "remindAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.remindAt[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return DateTime.mockValue - } - } - - func sendNotification() throws -> Bool { - let field = GraphQLField.leaf( - name: "sendNotification", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.sendNotification[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Bool.mockValue - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias Reminder = Selection -} - -extension Objects { - struct ReminderError { - let __typename: TypeName = .reminderError - let errorCodes: [String: [Enums.ReminderErrorCode]] - - enum TypeName: String, Codable { - case reminderError = "ReminderError" - } - } -} - -extension Objects.ReminderError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.ReminderErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.ReminderError { - func errorCodes() throws -> [Enums.ReminderErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias ReminderError = Selection -} - -extension Objects { - struct ReminderSuccess { - let __typename: TypeName = .reminderSuccess - let reminder: [String: Objects.Reminder] - - enum TypeName: String, Codable { - case reminderSuccess = "ReminderSuccess" - } - } -} - -extension Objects.ReminderSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "reminder": - if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - reminder = map["reminder"] - } -} - -extension Fields where TypeLock == Objects.ReminderSuccess { - func reminder(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "reminder", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.reminder[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias ReminderSuccess = Selection -} - -extension Objects { - struct ReportItemResult { - let __typename: TypeName = .reportItemResult - let message: [String: String] - - enum TypeName: String, Codable { - case reportItemResult = "ReportItemResult" - } - } -} - -extension Objects.ReportItemResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "message": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - message = map["message"] - } -} - -extension Fields where TypeLock == Objects.ReportItemResult { - func message() throws -> String { - let field = GraphQLField.leaf( - name: "message", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.message[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias ReportItemResult = Selection -} - -extension Objects { - struct SaveArticleReadingProgressError { - let __typename: TypeName = .saveArticleReadingProgressError - let errorCodes: [String: [Enums.SaveArticleReadingProgressErrorCode]] - - enum TypeName: String, Codable { - case saveArticleReadingProgressError = "SaveArticleReadingProgressError" - } - } -} - -extension Objects.SaveArticleReadingProgressError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SaveArticleReadingProgressErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.SaveArticleReadingProgressError { - func errorCodes() throws -> [Enums.SaveArticleReadingProgressErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SaveArticleReadingProgressError = Selection -} - -extension Objects { - struct SaveArticleReadingProgressSuccess { - let __typename: TypeName = .saveArticleReadingProgressSuccess - let updatedArticle: [String: Objects.Article] - - enum TypeName: String, Codable { - case saveArticleReadingProgressSuccess = "SaveArticleReadingProgressSuccess" - } - } -} - -extension Objects.SaveArticleReadingProgressSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "updatedArticle": - if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - updatedArticle = map["updatedArticle"] - } -} - -extension Fields where TypeLock == Objects.SaveArticleReadingProgressSuccess { - func updatedArticle(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "updatedArticle", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.updatedArticle[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SaveArticleReadingProgressSuccess = Selection -} - -extension Objects { - struct SaveError { - let __typename: TypeName = .saveError - let errorCodes: [String: [Enums.SaveErrorCode]] - let message: [String: String] - - enum TypeName: String, Codable { - case saveError = "SaveError" - } - } -} - -extension Objects.SaveError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SaveErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "message": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - message = map["message"] - } -} - -extension Fields where TypeLock == Objects.SaveError { - func errorCodes() throws -> [Enums.SaveErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } - - func message() throws -> String? { - let field = GraphQLField.leaf( - name: "message", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.message[field.alias!] - case .mocking: - return nil - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SaveError = Selection -} - -extension Objects { - struct SaveSuccess { - let __typename: TypeName = .saveSuccess - let clientRequestId: [String: String] - let url: [String: String] - - enum TypeName: String, Codable { - case saveSuccess = "SaveSuccess" - } - } -} - -extension Objects.SaveSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "clientRequestId": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "url": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - clientRequestId = map["clientRequestId"] - url = map["url"] - } -} - -extension Fields where TypeLock == Objects.SaveSuccess { - func clientRequestId() throws -> String { - let field = GraphQLField.leaf( - name: "clientRequestId", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.clientRequestId[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func url() throws -> String { - let field = GraphQLField.leaf( - name: "url", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.url[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SaveSuccess = Selection -} - -extension Objects { - struct SearchError { - let __typename: TypeName = .searchError - let errorCodes: [String: [Enums.SearchErrorCode]] - - enum TypeName: String, Codable { - case searchError = "SearchError" - } - } -} - -extension Objects.SearchError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SearchErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.SearchError { - func errorCodes() throws -> [Enums.SearchErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SearchError = Selection -} - -extension Objects { - struct SearchItem { - let __typename: TypeName = .searchItem - let annotation: [String: String] - let author: [String: String] - let contentReader: [String: Enums.ContentReader] - let createdAt: [String: DateTime] - let description: [String: String] - let id: [String: String] - let image: [String: String] - let isArchived: [String: Bool] - let labels: [String: [Objects.Label]] - let originalArticleUrl: [String: String] - let ownedByViewer: [String: Bool] - let pageId: [String: String] - let pageType: [String: Enums.PageType] - let publishedAt: [String: DateTime] - let quote: [String: String] - let readingProgressAnchorIndex: [String: Int] - let readingProgressPercent: [String: Double] - let shortId: [String: String] - let siteName: [String: String] - let slug: [String: String] - let state: [String: Enums.ArticleSavingRequestStatus] - let subscription: [String: String] - let title: [String: String] - let unsubHttpUrl: [String: String] - let unsubMailTo: [String: String] - let uploadFileId: [String: String] - let url: [String: String] - - enum TypeName: String, Codable { - case searchItem = "SearchItem" - } - } -} - -extension Objects.SearchItem: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "annotation": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "author": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "contentReader": - if let value = try container.decode(Enums.ContentReader?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "createdAt": - if let value = try container.decode(DateTime?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "description": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "id": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "image": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "isArchived": - if let value = try container.decode(Bool?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "labels": - if let value = try container.decode([Objects.Label]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "originalArticleUrl": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "ownedByViewer": - if let value = try container.decode(Bool?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "pageId": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "pageType": - if let value = try container.decode(Enums.PageType?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "publishedAt": - if let value = try container.decode(DateTime?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "quote": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "readingProgressAnchorIndex": - if let value = try container.decode(Int?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "readingProgressPercent": - if let value = try container.decode(Double?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "shortId": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "siteName": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "slug": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "state": - if let value = try container.decode(Enums.ArticleSavingRequestStatus?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "subscription": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "title": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "unsubHttpUrl": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "unsubMailTo": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "uploadFileId": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "url": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - annotation = map["annotation"] - author = map["author"] - contentReader = map["contentReader"] - createdAt = map["createdAt"] - description = map["description"] - id = map["id"] - image = map["image"] - isArchived = map["isArchived"] - labels = map["labels"] - originalArticleUrl = map["originalArticleUrl"] - ownedByViewer = map["ownedByViewer"] - pageId = map["pageId"] - pageType = map["pageType"] - publishedAt = map["publishedAt"] - quote = map["quote"] - readingProgressAnchorIndex = map["readingProgressAnchorIndex"] - readingProgressPercent = map["readingProgressPercent"] - shortId = map["shortId"] - siteName = map["siteName"] - slug = map["slug"] - state = map["state"] - subscription = map["subscription"] - title = map["title"] - unsubHttpUrl = map["unsubHttpUrl"] - unsubMailTo = map["unsubMailTo"] - uploadFileId = map["uploadFileId"] - url = map["url"] - } -} - -extension Fields where TypeLock == Objects.SearchItem { - func annotation() throws -> String? { - let field = GraphQLField.leaf( - name: "annotation", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.annotation[field.alias!] - case .mocking: - return nil - } - } - - func author() throws -> String? { - let field = GraphQLField.leaf( - name: "author", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.author[field.alias!] - case .mocking: - return nil - } - } - - func contentReader() throws -> Enums.ContentReader { - let field = GraphQLField.leaf( - name: "contentReader", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.contentReader[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Enums.ContentReader.allCases.first! - } - } - - func createdAt() throws -> DateTime { - let field = GraphQLField.leaf( - name: "createdAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.createdAt[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return DateTime.mockValue - } - } - - func description() throws -> String? { - let field = GraphQLField.leaf( - name: "description", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.description[field.alias!] - case .mocking: - return nil - } - } - - func id() throws -> String { - let field = GraphQLField.leaf( - name: "id", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.id[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func image() throws -> String? { - let field = GraphQLField.leaf( - name: "image", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.image[field.alias!] - case .mocking: - return nil - } - } - - func isArchived() throws -> Bool { - let field = GraphQLField.leaf( - name: "isArchived", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.isArchived[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Bool.mockValue - } - } - - func labels(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "labels", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - return try selection.decode(data: data.labels[field.alias!]) - case .mocking: - return selection.mock() - } - } - - func originalArticleUrl() throws -> String? { - let field = GraphQLField.leaf( - name: "originalArticleUrl", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.originalArticleUrl[field.alias!] - case .mocking: - return nil - } - } - - func ownedByViewer() throws -> Bool? { - let field = GraphQLField.leaf( - name: "ownedByViewer", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.ownedByViewer[field.alias!] - case .mocking: - return nil - } - } - - func pageId() throws -> String? { - let field = GraphQLField.leaf( - name: "pageId", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.pageId[field.alias!] - case .mocking: - return nil - } - } - - func pageType() throws -> Enums.PageType { - let field = GraphQLField.leaf( - name: "pageType", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.pageType[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Enums.PageType.allCases.first! - } - } - - func publishedAt() throws -> DateTime? { - let field = GraphQLField.leaf( - name: "publishedAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.publishedAt[field.alias!] - case .mocking: - return nil - } - } - - func quote() throws -> String? { - let field = GraphQLField.leaf( - name: "quote", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.quote[field.alias!] - case .mocking: - return nil - } - } - - func readingProgressAnchorIndex() throws -> Int? { - let field = GraphQLField.leaf( - name: "readingProgressAnchorIndex", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.readingProgressAnchorIndex[field.alias!] - case .mocking: - return nil - } - } - - func readingProgressPercent() throws -> Double? { - let field = GraphQLField.leaf( - name: "readingProgressPercent", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.readingProgressPercent[field.alias!] - case .mocking: - return nil - } - } - - func shortId() throws -> String? { - let field = GraphQLField.leaf( - name: "shortId", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.shortId[field.alias!] - case .mocking: - return nil - } - } - - func siteName() throws -> String? { - let field = GraphQLField.leaf( - name: "siteName", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.siteName[field.alias!] - case .mocking: - return nil - } - } - - func slug() throws -> String { - let field = GraphQLField.leaf( - name: "slug", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.slug[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func state() throws -> Enums.ArticleSavingRequestStatus? { - let field = GraphQLField.leaf( - name: "state", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.state[field.alias!] - case .mocking: - return nil - } - } - - func subscription() throws -> String? { - let field = GraphQLField.leaf( - name: "subscription", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.subscription[field.alias!] - case .mocking: - return nil - } - } - - func title() throws -> String { - let field = GraphQLField.leaf( - name: "title", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.title[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func unsubHttpUrl() throws -> String? { - let field = GraphQLField.leaf( - name: "unsubHttpUrl", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.unsubHttpUrl[field.alias!] - case .mocking: - return nil - } - } - - func unsubMailTo() throws -> String? { - let field = GraphQLField.leaf( - name: "unsubMailTo", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.unsubMailTo[field.alias!] - case .mocking: - return nil - } - } - - func uploadFileId() throws -> String? { - let field = GraphQLField.leaf( - name: "uploadFileId", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.uploadFileId[field.alias!] - case .mocking: - return nil - } - } - - func url() throws -> String { - let field = GraphQLField.leaf( - name: "url", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.url[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SearchItem = Selection -} - -extension Objects { - struct SearchItemEdge { - let __typename: TypeName = .searchItemEdge - let cursor: [String: String] - let node: [String: Objects.SearchItem] - - enum TypeName: String, Codable { - case searchItemEdge = "SearchItemEdge" - } - } -} - -extension Objects.SearchItemEdge: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "cursor": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "node": - if let value = try container.decode(Objects.SearchItem?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - cursor = map["cursor"] - node = map["node"] - } -} - -extension Fields where TypeLock == Objects.SearchItemEdge { - func cursor() throws -> String { - let field = GraphQLField.leaf( - name: "cursor", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.cursor[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func node(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "node", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.node[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SearchItemEdge = Selection -} - -extension Objects { - struct SearchSuccess { - let __typename: TypeName = .searchSuccess - let edges: [String: [Objects.SearchItemEdge]] - let pageInfo: [String: Objects.PageInfo] - - enum TypeName: String, Codable { - case searchSuccess = "SearchSuccess" - } - } -} - -extension Objects.SearchSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "edges": - if let value = try container.decode([Objects.SearchItemEdge]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "pageInfo": - if let value = try container.decode(Objects.PageInfo?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - edges = map["edges"] - pageInfo = map["pageInfo"] - } -} - -extension Fields where TypeLock == Objects.SearchSuccess { - func edges(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "edges", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.edges[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func pageInfo(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "pageInfo", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.pageInfo[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SearchSuccess = Selection -} - -extension Objects { - struct SetBookmarkArticleError { - let __typename: TypeName = .setBookmarkArticleError - let errorCodes: [String: [Enums.SetBookmarkArticleErrorCode]] - - enum TypeName: String, Codable { - case setBookmarkArticleError = "SetBookmarkArticleError" - } - } -} - -extension Objects.SetBookmarkArticleError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SetBookmarkArticleErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.SetBookmarkArticleError { - func errorCodes() throws -> [Enums.SetBookmarkArticleErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetBookmarkArticleError = Selection -} - -extension Objects { - struct SetBookmarkArticleSuccess { - let __typename: TypeName = .setBookmarkArticleSuccess - let bookmarkedArticle: [String: Objects.Article] - - enum TypeName: String, Codable { - case setBookmarkArticleSuccess = "SetBookmarkArticleSuccess" - } - } -} - -extension Objects.SetBookmarkArticleSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "bookmarkedArticle": - if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - bookmarkedArticle = map["bookmarkedArticle"] - } -} - -extension Fields where TypeLock == Objects.SetBookmarkArticleSuccess { - func bookmarkedArticle(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "bookmarkedArticle", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.bookmarkedArticle[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetBookmarkArticleSuccess = Selection -} - -extension Objects { - struct SetDeviceTokenError { - let __typename: TypeName = .setDeviceTokenError - let errorCodes: [String: [Enums.SetDeviceTokenErrorCode]] - - enum TypeName: String, Codable { - case setDeviceTokenError = "SetDeviceTokenError" - } - } -} - -extension Objects.SetDeviceTokenError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SetDeviceTokenErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.SetDeviceTokenError { - func errorCodes() throws -> [Enums.SetDeviceTokenErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetDeviceTokenError = Selection -} - -extension Objects { - struct SetDeviceTokenSuccess { - let __typename: TypeName = .setDeviceTokenSuccess - let deviceToken: [String: Objects.DeviceToken] - - enum TypeName: String, Codable { - case setDeviceTokenSuccess = "SetDeviceTokenSuccess" - } - } -} - -extension Objects.SetDeviceTokenSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "deviceToken": - if let value = try container.decode(Objects.DeviceToken?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - deviceToken = map["deviceToken"] - } -} - -extension Fields where TypeLock == Objects.SetDeviceTokenSuccess { - func deviceToken(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "deviceToken", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.deviceToken[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetDeviceTokenSuccess = Selection -} - -extension Objects { - struct SetFollowError { - let __typename: TypeName = .setFollowError - let errorCodes: [String: [Enums.SetFollowErrorCode]] - - enum TypeName: String, Codable { - case setFollowError = "SetFollowError" - } - } -} - -extension Objects.SetFollowError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SetFollowErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.SetFollowError { - func errorCodes() throws -> [Enums.SetFollowErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetFollowError = Selection -} - -extension Objects { - struct SetFollowSuccess { - let __typename: TypeName = .setFollowSuccess - let updatedUser: [String: Objects.User] - - enum TypeName: String, Codable { - case setFollowSuccess = "SetFollowSuccess" - } - } -} - -extension Objects.SetFollowSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "updatedUser": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - updatedUser = map["updatedUser"] - } -} - -extension Fields where TypeLock == Objects.SetFollowSuccess { - func updatedUser(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "updatedUser", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.updatedUser[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetFollowSuccess = Selection -} - -extension Objects { - struct SetLabelsError { - let __typename: TypeName = .setLabelsError - let errorCodes: [String: [Enums.SetLabelsErrorCode]] - - enum TypeName: String, Codable { - case setLabelsError = "SetLabelsError" - } - } -} - -extension Objects.SetLabelsError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SetLabelsErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.SetLabelsError { - func errorCodes() throws -> [Enums.SetLabelsErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetLabelsError = Selection -} - -extension Objects { - struct SetLabelsSuccess { - let __typename: TypeName = .setLabelsSuccess - let labels: [String: [Objects.Label]] - - enum TypeName: String, Codable { - case setLabelsSuccess = "SetLabelsSuccess" - } - } -} - -extension Objects.SetLabelsSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "labels": - if let value = try container.decode([Objects.Label]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - labels = map["labels"] - } -} - -extension Fields where TypeLock == Objects.SetLabelsSuccess { - func labels(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "labels", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.labels[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetLabelsSuccess = Selection -} - -extension Objects { - struct SetShareArticleError { - let __typename: TypeName = .setShareArticleError - let errorCodes: [String: [Enums.SetShareArticleErrorCode]] - - enum TypeName: String, Codable { - case setShareArticleError = "SetShareArticleError" - } - } -} - -extension Objects.SetShareArticleError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SetShareArticleErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.SetShareArticleError { - func errorCodes() throws -> [Enums.SetShareArticleErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetShareArticleError = Selection -} - -extension Objects { - struct SetShareArticleSuccess { - let __typename: TypeName = .setShareArticleSuccess - let updatedArticle: [String: Objects.Article] - let updatedFeedArticle: [String: Objects.FeedArticle] - let updatedFeedArticleId: [String: String] - - enum TypeName: String, Codable { - case setShareArticleSuccess = "SetShareArticleSuccess" - } - } -} - -extension Objects.SetShareArticleSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "updatedArticle": - if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "updatedFeedArticle": - if let value = try container.decode(Objects.FeedArticle?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "updatedFeedArticleId": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - updatedArticle = map["updatedArticle"] - updatedFeedArticle = map["updatedFeedArticle"] - updatedFeedArticleId = map["updatedFeedArticleId"] - } -} - -extension Fields where TypeLock == Objects.SetShareArticleSuccess { - func updatedArticle(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "updatedArticle", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.updatedArticle[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func updatedFeedArticle(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "updatedFeedArticle", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - return try selection.decode(data: data.updatedFeedArticle[field.alias!]) - case .mocking: - return selection.mock() - } - } - - func updatedFeedArticleId() throws -> String? { - let field = GraphQLField.leaf( - name: "updatedFeedArticleId", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.updatedFeedArticleId[field.alias!] - case .mocking: - return nil - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetShareArticleSuccess = Selection -} - -extension Objects { - struct SetShareHighlightError { - let __typename: TypeName = .setShareHighlightError - let errorCodes: [String: [Enums.SetShareHighlightErrorCode]] - - enum TypeName: String, Codable { - case setShareHighlightError = "SetShareHighlightError" - } - } -} - -extension Objects.SetShareHighlightError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SetShareHighlightErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.SetShareHighlightError { - func errorCodes() throws -> [Enums.SetShareHighlightErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetShareHighlightError = Selection -} - -extension Objects { - struct SetShareHighlightSuccess { - let __typename: TypeName = .setShareHighlightSuccess - let highlight: [String: Objects.Highlight] - - enum TypeName: String, Codable { - case setShareHighlightSuccess = "SetShareHighlightSuccess" - } - } -} - -extension Objects.SetShareHighlightSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "highlight": - if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - highlight = map["highlight"] - } -} - -extension Fields where TypeLock == Objects.SetShareHighlightSuccess { - func highlight(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "highlight", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.highlight[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetShareHighlightSuccess = Selection -} - -extension Objects { - struct SetUserPersonalizationError { - let __typename: TypeName = .setUserPersonalizationError - let errorCodes: [String: [Enums.SetUserPersonalizationErrorCode]] - - enum TypeName: String, Codable { - case setUserPersonalizationError = "SetUserPersonalizationError" - } - } -} - -extension Objects.SetUserPersonalizationError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SetUserPersonalizationErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.SetUserPersonalizationError { - func errorCodes() throws -> [Enums.SetUserPersonalizationErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetUserPersonalizationError = Selection -} - -extension Objects { - struct SetUserPersonalizationSuccess { - let __typename: TypeName = .setUserPersonalizationSuccess - let updatedUserPersonalization: [String: Objects.UserPersonalization] - - enum TypeName: String, Codable { - case setUserPersonalizationSuccess = "SetUserPersonalizationSuccess" - } - } -} - -extension Objects.SetUserPersonalizationSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "updatedUserPersonalization": - if let value = try container.decode(Objects.UserPersonalization?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - updatedUserPersonalization = map["updatedUserPersonalization"] - } -} - -extension Fields where TypeLock == Objects.SetUserPersonalizationSuccess { - func updatedUserPersonalization(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "updatedUserPersonalization", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.updatedUserPersonalization[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetUserPersonalizationSuccess = Selection -} - -extension Objects { - struct SharedArticleError { - let __typename: TypeName = .sharedArticleError - let errorCodes: [String: [Enums.SharedArticleErrorCode]] - - enum TypeName: String, Codable { - case sharedArticleError = "SharedArticleError" - } - } -} - -extension Objects.SharedArticleError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SharedArticleErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.SharedArticleError { - func errorCodes() throws -> [Enums.SharedArticleErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SharedArticleError = Selection -} - -extension Objects { - struct SharedArticleSuccess { - let __typename: TypeName = .sharedArticleSuccess - let article: [String: Objects.Article] - - enum TypeName: String, Codable { - case sharedArticleSuccess = "SharedArticleSuccess" - } - } -} - -extension Objects.SharedArticleSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "article": - if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - article = map["article"] - } -} - -extension Fields where TypeLock == Objects.SharedArticleSuccess { - func article(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "article", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.article[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SharedArticleSuccess = Selection -} - -extension Objects { - struct ShareStats { - let __typename: TypeName = .shareStats - let readDuration: [String: Int] - let saveCount: [String: Int] - let viewCount: [String: Int] - - enum TypeName: String, Codable { - case shareStats = "ShareStats" - } - } -} - -extension Objects.ShareStats: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "readDuration": - if let value = try container.decode(Int?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "saveCount": - if let value = try container.decode(Int?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "viewCount": - if let value = try container.decode(Int?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - readDuration = map["readDuration"] - saveCount = map["saveCount"] - viewCount = map["viewCount"] - } -} - -extension Fields where TypeLock == Objects.ShareStats { - func readDuration() throws -> Int { - let field = GraphQLField.leaf( - name: "readDuration", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.readDuration[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Int.mockValue - } - } - - func saveCount() throws -> Int { - let field = GraphQLField.leaf( - name: "saveCount", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.saveCount[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Int.mockValue - } - } - - func viewCount() throws -> Int { - let field = GraphQLField.leaf( - name: "viewCount", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.viewCount[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Int.mockValue - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias ShareStats = Selection -} - -extension Objects { - struct SignupError { - let __typename: TypeName = .signupError - let errorCodes: [String: [Enums.SignupErrorCode?]] - - enum TypeName: String, Codable { - case signupError = "SignupError" - } - } -} - -extension Objects.SignupError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SignupErrorCode?]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.SignupError { - func errorCodes() throws -> [Enums.SignupErrorCode?] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SignupError = Selection -} - -extension Objects { - struct SignupSuccess { - let __typename: TypeName = .signupSuccess - let me: [String: Objects.User] - - enum TypeName: String, Codable { - case signupSuccess = "SignupSuccess" - } - } -} - -extension Objects.SignupSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "me": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - me = map["me"] - } -} - -extension Fields where TypeLock == Objects.SignupSuccess { - func me(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "me", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.me[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SignupSuccess = Selection -} - -extension Objects { - struct SubscribeError { - let __typename: TypeName = .subscribeError - let errorCodes: [String: [Enums.SubscribeErrorCode]] - - enum TypeName: String, Codable { - case subscribeError = "SubscribeError" - } - } -} - -extension Objects.SubscribeError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SubscribeErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.SubscribeError { - func errorCodes() throws -> [Enums.SubscribeErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SubscribeError = Selection -} - -extension Objects { - struct SubscribeSuccess { - let __typename: TypeName = .subscribeSuccess - let subscriptions: [String: [Objects.Subscription]] - - enum TypeName: String, Codable { - case subscribeSuccess = "SubscribeSuccess" - } - } -} - -extension Objects.SubscribeSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "subscriptions": - if let value = try container.decode([Objects.Subscription]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - subscriptions = map["subscriptions"] - } -} - -extension Fields where TypeLock == Objects.SubscribeSuccess { - func subscriptions(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "subscriptions", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.subscriptions[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SubscribeSuccess = Selection -} - -extension Objects { - struct Subscription { - let __typename: TypeName = .subscription - let createdAt: [String: DateTime] - let description: [String: String] - let id: [String: String] - let name: [String: String] - let newsletterEmail: [String: String] - let status: [String: Enums.SubscriptionStatus] - let unsubscribeHttpUrl: [String: String] - let unsubscribeMailTo: [String: String] - let updatedAt: [String: DateTime] - let url: [String: String] - - enum TypeName: String, Codable { - case subscription = "Subscription" - } - } -} - -extension Objects.Subscription: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "createdAt": - if let value = try container.decode(DateTime?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "description": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "id": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "name": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "newsletterEmail": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "status": - if let value = try container.decode(Enums.SubscriptionStatus?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "unsubscribeHttpUrl": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "unsubscribeMailTo": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "updatedAt": - if let value = try container.decode(DateTime?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "url": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - createdAt = map["createdAt"] - description = map["description"] - id = map["id"] - name = map["name"] - newsletterEmail = map["newsletterEmail"] - status = map["status"] - unsubscribeHttpUrl = map["unsubscribeHttpUrl"] - unsubscribeMailTo = map["unsubscribeMailTo"] - updatedAt = map["updatedAt"] - url = map["url"] - } -} - -extension Fields where TypeLock == Objects.Subscription { - func createdAt() throws -> DateTime { - let field = GraphQLField.leaf( - name: "createdAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.createdAt[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return DateTime.mockValue - } - } - - func description() throws -> String? { - let field = GraphQLField.leaf( - name: "description", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.description[field.alias!] - case .mocking: - return nil - } - } - - func id() throws -> String { - let field = GraphQLField.leaf( - name: "id", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.id[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func name() throws -> String { - let field = GraphQLField.leaf( - name: "name", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.name[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func newsletterEmail() throws -> String { - let field = GraphQLField.leaf( - name: "newsletterEmail", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.newsletterEmail[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func status() throws -> Enums.SubscriptionStatus { - let field = GraphQLField.leaf( - name: "status", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.status[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return Enums.SubscriptionStatus.allCases.first! - } - } - - func unsubscribeHttpUrl() throws -> String? { - let field = GraphQLField.leaf( - name: "unsubscribeHttpUrl", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.unsubscribeHttpUrl[field.alias!] - case .mocking: - return nil - } - } - - func unsubscribeMailTo() throws -> String? { - let field = GraphQLField.leaf( - name: "unsubscribeMailTo", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.unsubscribeMailTo[field.alias!] - case .mocking: - return nil - } - } - - func updatedAt() throws -> DateTime { - let field = GraphQLField.leaf( - name: "updatedAt", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.updatedAt[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return DateTime.mockValue - } - } - - func url() throws -> String? { - let field = GraphQLField.leaf( - name: "url", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.url[field.alias!] - case .mocking: - return nil - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias Subscription = Selection -} - -extension Objects { - struct SubscriptionsError { - let __typename: TypeName = .subscriptionsError - let errorCodes: [String: [Enums.SubscriptionsErrorCode]] - - enum TypeName: String, Codable { - case subscriptionsError = "SubscriptionsError" - } - } -} - -extension Objects.SubscriptionsError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SubscriptionsErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.SubscriptionsError { - func errorCodes() throws -> [Enums.SubscriptionsErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SubscriptionsError = Selection -} - -extension Objects { - struct SubscriptionsSuccess { - let __typename: TypeName = .subscriptionsSuccess - let subscriptions: [String: [Objects.Subscription]] - - enum TypeName: String, Codable { - case subscriptionsSuccess = "SubscriptionsSuccess" - } - } -} - -extension Objects.SubscriptionsSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "subscriptions": - if let value = try container.decode([Objects.Subscription]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - subscriptions = map["subscriptions"] - } -} - -extension Fields where TypeLock == Objects.SubscriptionsSuccess { - func subscriptions(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "subscriptions", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.subscriptions[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SubscriptionsSuccess = Selection -} - -extension Objects { - struct UnsubscribeError { - let __typename: TypeName = .unsubscribeError - let errorCodes: [String: [Enums.UnsubscribeErrorCode]] - - enum TypeName: String, Codable { - case unsubscribeError = "UnsubscribeError" - } - } -} - -extension Objects.UnsubscribeError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UnsubscribeErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.UnsubscribeError { - func errorCodes() throws -> [Enums.UnsubscribeErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UnsubscribeError = Selection -} - -extension Objects { - struct UnsubscribeSuccess { - let __typename: TypeName = .unsubscribeSuccess - let subscription: [String: Objects.Subscription] - - enum TypeName: String, Codable { - case unsubscribeSuccess = "UnsubscribeSuccess" - } - } -} - -extension Objects.UnsubscribeSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "subscription": - if let value = try container.decode(Objects.Subscription?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - subscription = map["subscription"] - } -} - -extension Fields where TypeLock == Objects.UnsubscribeSuccess { - func subscription(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "subscription", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.subscription[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UnsubscribeSuccess = Selection -} - -extension Objects { - struct UpdateHighlightError { - let __typename: TypeName = .updateHighlightError - let errorCodes: [String: [Enums.UpdateHighlightErrorCode]] - - enum TypeName: String, Codable { - case updateHighlightError = "UpdateHighlightError" - } - } -} - -extension Objects.UpdateHighlightError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdateHighlightErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.UpdateHighlightError { - func errorCodes() throws -> [Enums.UpdateHighlightErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateHighlightError = Selection -} - -extension Objects { - struct UpdateHighlightReplyError { - let __typename: TypeName = .updateHighlightReplyError - let errorCodes: [String: [Enums.UpdateHighlightReplyErrorCode]] - - enum TypeName: String, Codable { - case updateHighlightReplyError = "UpdateHighlightReplyError" - } - } -} - -extension Objects.UpdateHighlightReplyError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdateHighlightReplyErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.UpdateHighlightReplyError { - func errorCodes() throws -> [Enums.UpdateHighlightReplyErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateHighlightReplyError = Selection -} - -extension Objects { - struct UpdateHighlightReplySuccess { - let __typename: TypeName = .updateHighlightReplySuccess - let highlightReply: [String: Objects.HighlightReply] - - enum TypeName: String, Codable { - case updateHighlightReplySuccess = "UpdateHighlightReplySuccess" - } - } -} - -extension Objects.UpdateHighlightReplySuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "highlightReply": - if let value = try container.decode(Objects.HighlightReply?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - highlightReply = map["highlightReply"] - } -} - -extension Fields where TypeLock == Objects.UpdateHighlightReplySuccess { - func highlightReply(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "highlightReply", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.highlightReply[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateHighlightReplySuccess = Selection -} - -extension Objects { - struct UpdateHighlightSuccess { - let __typename: TypeName = .updateHighlightSuccess - let highlight: [String: Objects.Highlight] - - enum TypeName: String, Codable { - case updateHighlightSuccess = "UpdateHighlightSuccess" - } - } -} - -extension Objects.UpdateHighlightSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "highlight": - if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - highlight = map["highlight"] - } -} - -extension Fields where TypeLock == Objects.UpdateHighlightSuccess { - func highlight(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "highlight", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.highlight[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateHighlightSuccess = Selection -} - -extension Objects { - struct UpdateLabelError { - let __typename: TypeName = .updateLabelError - let errorCodes: [String: [Enums.UpdateLabelErrorCode]] - - enum TypeName: String, Codable { - case updateLabelError = "UpdateLabelError" - } - } -} - -extension Objects.UpdateLabelError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdateLabelErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.UpdateLabelError { - func errorCodes() throws -> [Enums.UpdateLabelErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateLabelError = Selection -} - -extension Objects { - struct UpdateLabelSuccess { - let __typename: TypeName = .updateLabelSuccess - let label: [String: Objects.Label] - - enum TypeName: String, Codable { - case updateLabelSuccess = "UpdateLabelSuccess" - } - } -} - -extension Objects.UpdateLabelSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "label": - if let value = try container.decode(Objects.Label?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - label = map["label"] - } -} - -extension Fields where TypeLock == Objects.UpdateLabelSuccess { - func label(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "label", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.label[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateLabelSuccess = Selection -} - -extension Objects { - struct UpdateLinkShareInfoError { - let __typename: TypeName = .updateLinkShareInfoError - let errorCodes: [String: [Enums.UpdateLinkShareInfoErrorCode]] - - enum TypeName: String, Codable { - case updateLinkShareInfoError = "UpdateLinkShareInfoError" - } - } -} - -extension Objects.UpdateLinkShareInfoError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdateLinkShareInfoErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.UpdateLinkShareInfoError { - func errorCodes() throws -> [Enums.UpdateLinkShareInfoErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateLinkShareInfoError = Selection -} - -extension Objects { - struct UpdateLinkShareInfoSuccess { - let __typename: TypeName = .updateLinkShareInfoSuccess - let message: [String: String] - - enum TypeName: String, Codable { - case updateLinkShareInfoSuccess = "UpdateLinkShareInfoSuccess" - } - } -} - -extension Objects.UpdateLinkShareInfoSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "message": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - message = map["message"] - } -} - -extension Fields where TypeLock == Objects.UpdateLinkShareInfoSuccess { - func message() throws -> String { - let field = GraphQLField.leaf( - name: "message", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.message[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateLinkShareInfoSuccess = Selection -} - -extension Objects { - struct UpdatePageError { - let __typename: TypeName = .updatePageError - let errorCodes: [String: [Enums.UpdatePageErrorCode]] - - enum TypeName: String, Codable { - case updatePageError = "UpdatePageError" - } - } -} - -extension Objects.UpdatePageError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdatePageErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.UpdatePageError { - func errorCodes() throws -> [Enums.UpdatePageErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdatePageError = Selection -} - -extension Objects { - struct UpdatePageSuccess { - let __typename: TypeName = .updatePageSuccess - let updatedPage: [String: Objects.Page] - - enum TypeName: String, Codable { - case updatePageSuccess = "UpdatePageSuccess" - } - } -} - -extension Objects.UpdatePageSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "updatedPage": - if let value = try container.decode(Objects.Page?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - updatedPage = map["updatedPage"] - } -} - -extension Fields where TypeLock == Objects.UpdatePageSuccess { - func updatedPage(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "updatedPage", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.updatedPage[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdatePageSuccess = Selection -} - -extension Objects { - struct UpdateReminderError { - let __typename: TypeName = .updateReminderError - let errorCodes: [String: [Enums.UpdateReminderErrorCode]] - - enum TypeName: String, Codable { - case updateReminderError = "UpdateReminderError" - } - } -} - -extension Objects.UpdateReminderError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdateReminderErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.UpdateReminderError { - func errorCodes() throws -> [Enums.UpdateReminderErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateReminderError = Selection -} - -extension Objects { - struct UpdateReminderSuccess { - let __typename: TypeName = .updateReminderSuccess - let reminder: [String: Objects.Reminder] - - enum TypeName: String, Codable { - case updateReminderSuccess = "UpdateReminderSuccess" - } - } -} - -extension Objects.UpdateReminderSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "reminder": - if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - reminder = map["reminder"] - } -} - -extension Fields where TypeLock == Objects.UpdateReminderSuccess { - func reminder(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "reminder", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.reminder[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateReminderSuccess = Selection -} - -extension Objects { - struct UpdateSharedCommentError { - let __typename: TypeName = .updateSharedCommentError - let errorCodes: [String: [Enums.UpdateSharedCommentErrorCode]] - - enum TypeName: String, Codable { - case updateSharedCommentError = "UpdateSharedCommentError" - } - } -} - -extension Objects.UpdateSharedCommentError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdateSharedCommentErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.UpdateSharedCommentError { - func errorCodes() throws -> [Enums.UpdateSharedCommentErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateSharedCommentError = Selection -} - -extension Objects { - struct UpdateSharedCommentSuccess { - let __typename: TypeName = .updateSharedCommentSuccess - let articleId: [String: String] - let sharedComment: [String: String] - - enum TypeName: String, Codable { - case updateSharedCommentSuccess = "UpdateSharedCommentSuccess" - } - } -} - -extension Objects.UpdateSharedCommentSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "articleId": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "sharedComment": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - articleId = map["articleId"] - sharedComment = map["sharedComment"] - } -} - -extension Fields where TypeLock == Objects.UpdateSharedCommentSuccess { - func articleId() throws -> String { - let field = GraphQLField.leaf( - name: "articleID", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.articleId[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func sharedComment() throws -> String { - let field = GraphQLField.leaf( - name: "sharedComment", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.sharedComment[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateSharedCommentSuccess = Selection -} - -extension Objects { - struct UpdateUserError { - let __typename: TypeName = .updateUserError - let errorCodes: [String: [Enums.UpdateUserErrorCode]] - - enum TypeName: String, Codable { - case updateUserError = "UpdateUserError" - } - } -} - -extension Objects.UpdateUserError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdateUserErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.UpdateUserError { - func errorCodes() throws -> [Enums.UpdateUserErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateUserError = Selection -} - -extension Objects { - struct UpdateUserProfileError { - let __typename: TypeName = .updateUserProfileError - let errorCodes: [String: [Enums.UpdateUserProfileErrorCode]] - - enum TypeName: String, Codable { - case updateUserProfileError = "UpdateUserProfileError" - } - } -} - -extension Objects.UpdateUserProfileError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdateUserProfileErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.UpdateUserProfileError { - func errorCodes() throws -> [Enums.UpdateUserProfileErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateUserProfileError = Selection -} - -extension Objects { - struct UpdateUserProfileSuccess { - let __typename: TypeName = .updateUserProfileSuccess - let user: [String: Objects.User] - - enum TypeName: String, Codable { - case updateUserProfileSuccess = "UpdateUserProfileSuccess" - } - } -} - -extension Objects.UpdateUserProfileSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "user": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - user = map["user"] - } -} - -extension Fields where TypeLock == Objects.UpdateUserProfileSuccess { - func user(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "user", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.user[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateUserProfileSuccess = Selection -} - -extension Objects { - struct UpdateUserSuccess { - let __typename: TypeName = .updateUserSuccess - let user: [String: Objects.User] - - enum TypeName: String, Codable { - case updateUserSuccess = "UpdateUserSuccess" - } - } -} - -extension Objects.UpdateUserSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "user": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - user = map["user"] - } -} - -extension Fields where TypeLock == Objects.UpdateUserSuccess { - func user(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "user", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.user[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateUserSuccess = Selection -} - -extension Objects { - struct UploadFileRequestError { - let __typename: TypeName = .uploadFileRequestError - let errorCodes: [String: [Enums.UploadFileRequestErrorCode]] - - enum TypeName: String, Codable { - case uploadFileRequestError = "UploadFileRequestError" - } - } -} - -extension Objects.UploadFileRequestError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UploadFileRequestErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.UploadFileRequestError { - func errorCodes() throws -> [Enums.UploadFileRequestErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UploadFileRequestError = Selection -} - -extension Objects { - struct UploadFileRequestSuccess { - let __typename: TypeName = .uploadFileRequestSuccess - let id: [String: String] - let uploadFileId: [String: String] - let uploadSignedUrl: [String: String] - - enum TypeName: String, Codable { - case uploadFileRequestSuccess = "UploadFileRequestSuccess" - } - } -} - -extension Objects.UploadFileRequestSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "id": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "uploadFileId": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "uploadSignedUrl": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - id = map["id"] - uploadFileId = map["uploadFileId"] - uploadSignedUrl = map["uploadSignedUrl"] - } -} - -extension Fields where TypeLock == Objects.UploadFileRequestSuccess { - func id() throws -> String { - let field = GraphQLField.leaf( - name: "id", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.id[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func uploadFileId() throws -> String? { - let field = GraphQLField.leaf( - name: "uploadFileId", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.uploadFileId[field.alias!] - case .mocking: - return nil - } - } - - func uploadSignedUrl() throws -> String? { - let field = GraphQLField.leaf( - name: "uploadSignedUrl", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.uploadSignedUrl[field.alias!] - case .mocking: - return nil - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UploadFileRequestSuccess = Selection -} - -extension Objects { - struct User { - let __typename: TypeName = .user - let followersCount: [String: Int] - let friendsCount: [String: Int] - let id: [String: String] - let isFriend: [String: Bool] - let isFullUser: [String: Bool] - let name: [String: String] - let picture: [String: String] - let profile: [String: Objects.Profile] - let sharedArticles: [String: [Objects.FeedArticle]] - let sharedArticlesCount: [String: Int] - let sharedHighlightsCount: [String: Int] - let sharedNotesCount: [String: Int] - let viewerIsFollowing: [String: Bool] - - enum TypeName: String, Codable { - case user = "User" - } - } -} - -extension Objects.User: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "followersCount": - if let value = try container.decode(Int?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "friendsCount": - if let value = try container.decode(Int?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "id": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "isFriend": - if let value = try container.decode(Bool?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "isFullUser": - if let value = try container.decode(Bool?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "name": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "picture": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "profile": - if let value = try container.decode(Objects.Profile?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "sharedArticles": - if let value = try container.decode([Objects.FeedArticle]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "sharedArticlesCount": - if let value = try container.decode(Int?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "sharedHighlightsCount": - if let value = try container.decode(Int?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "sharedNotesCount": - if let value = try container.decode(Int?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "viewerIsFollowing": - if let value = try container.decode(Bool?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - followersCount = map["followersCount"] - friendsCount = map["friendsCount"] - id = map["id"] - isFriend = map["isFriend"] - isFullUser = map["isFullUser"] - name = map["name"] - picture = map["picture"] - profile = map["profile"] - sharedArticles = map["sharedArticles"] - sharedArticlesCount = map["sharedArticlesCount"] - sharedHighlightsCount = map["sharedHighlightsCount"] - sharedNotesCount = map["sharedNotesCount"] - viewerIsFollowing = map["viewerIsFollowing"] - } -} - -extension Fields where TypeLock == Objects.User { - func followersCount() throws -> Int? { - let field = GraphQLField.leaf( - name: "followersCount", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.followersCount[field.alias!] - case .mocking: - return nil - } - } - - func friendsCount() throws -> Int? { - let field = GraphQLField.leaf( - name: "friendsCount", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.friendsCount[field.alias!] - case .mocking: - return nil - } - } - - func id() throws -> String { - let field = GraphQLField.leaf( - name: "id", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.id[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - @available(*, deprecated, message: "isFriend has been replaced with viewerIsFollowing") - func isFriend() throws -> Bool? { - let field = GraphQLField.leaf( - name: "isFriend", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.isFriend[field.alias!] - case .mocking: - return nil - } - } - - func isFullUser() throws -> Bool? { - let field = GraphQLField.leaf( - name: "isFullUser", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.isFullUser[field.alias!] - case .mocking: - return nil - } - } - - func name() throws -> String { - let field = GraphQLField.leaf( - name: "name", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.name[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return String.mockValue - } - } - - func picture() throws -> String? { - let field = GraphQLField.leaf( - name: "picture", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.picture[field.alias!] - case .mocking: - return nil - } - } - - func profile(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "profile", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.profile[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func sharedArticles(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "sharedArticles", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.sharedArticles[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } - - func sharedArticlesCount() throws -> Int? { - let field = GraphQLField.leaf( - name: "sharedArticlesCount", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.sharedArticlesCount[field.alias!] - case .mocking: - return nil - } - } - - func sharedHighlightsCount() throws -> Int? { - let field = GraphQLField.leaf( - name: "sharedHighlightsCount", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.sharedHighlightsCount[field.alias!] - case .mocking: - return nil - } - } - - func sharedNotesCount() throws -> Int? { - let field = GraphQLField.leaf( - name: "sharedNotesCount", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.sharedNotesCount[field.alias!] - case .mocking: - return nil - } - } - - func viewerIsFollowing() throws -> Bool? { - let field = GraphQLField.leaf( - name: "viewerIsFollowing", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.viewerIsFollowing[field.alias!] - case .mocking: - return nil - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias User = Selection -} - -extension Objects { - struct UserError { - let __typename: TypeName = .userError +enum Unions {} +extension Unions { + struct UserResult { + let __typename: TypeName let errorCodes: [String: [Enums.UserErrorCode]] + let user: [String: Objects.User] enum TypeName: String, Codable { + case userSuccess = "UserSuccess" case userError = "UserError" } } } -extension Objects.UserError: Decodable { +extension Unions.UserResult: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -14949,386 +15450,6 @@ extension Objects.UserError: Decodable { if let value = try container.decode([Enums.UserErrorCode]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.UserError { - func errorCodes() throws -> [Enums.UserErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UserError = Selection -} - -extension Objects { - struct UserPersonalization { - let __typename: TypeName = .userPersonalization - let fontFamily: [String: String] - let fontSize: [String: Int] - let id: [String: String] - let libraryLayoutType: [String: String] - let librarySortOrder: [String: Enums.SortOrder] - let margin: [String: Int] - let theme: [String: String] - - enum TypeName: String, Codable { - case userPersonalization = "UserPersonalization" - } - } -} - -extension Objects.UserPersonalization: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "fontFamily": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "fontSize": - if let value = try container.decode(Int?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "id": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "libraryLayoutType": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "librarySortOrder": - if let value = try container.decode(Enums.SortOrder?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "margin": - if let value = try container.decode(Int?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "theme": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - fontFamily = map["fontFamily"] - fontSize = map["fontSize"] - id = map["id"] - libraryLayoutType = map["libraryLayoutType"] - librarySortOrder = map["librarySortOrder"] - margin = map["margin"] - theme = map["theme"] - } -} - -extension Fields where TypeLock == Objects.UserPersonalization { - func fontFamily() throws -> String? { - let field = GraphQLField.leaf( - name: "fontFamily", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.fontFamily[field.alias!] - case .mocking: - return nil - } - } - - func fontSize() throws -> Int? { - let field = GraphQLField.leaf( - name: "fontSize", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.fontSize[field.alias!] - case .mocking: - return nil - } - } - - func id() throws -> String? { - let field = GraphQLField.leaf( - name: "id", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.id[field.alias!] - case .mocking: - return nil - } - } - - func libraryLayoutType() throws -> String? { - let field = GraphQLField.leaf( - name: "libraryLayoutType", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.libraryLayoutType[field.alias!] - case .mocking: - return nil - } - } - - func librarySortOrder() throws -> Enums.SortOrder? { - let field = GraphQLField.leaf( - name: "librarySortOrder", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.librarySortOrder[field.alias!] - case .mocking: - return nil - } - } - - func margin() throws -> Int? { - let field = GraphQLField.leaf( - name: "margin", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.margin[field.alias!] - case .mocking: - return nil - } - } - - func theme() throws -> String? { - let field = GraphQLField.leaf( - name: "theme", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - return data.theme[field.alias!] - case .mocking: - return nil - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UserPersonalization = Selection -} - -extension Objects { - struct UsersError { - let __typename: TypeName = .usersError - let errorCodes: [String: [Enums.UsersErrorCode]] - - enum TypeName: String, Codable { - case usersError = "UsersError" - } - } -} - -extension Objects.UsersError: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UsersErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Objects.UsersError { - func errorCodes() throws -> [Enums.UsersErrorCode] { - let field = GraphQLField.leaf( - name: "errorCodes", - arguments: [] - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.errorCodes[field.alias!] { - return data - } - throw HttpError.badpayload - case .mocking: - return [] - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UsersError = Selection -} - -extension Objects { - struct UsersSuccess { - let __typename: TypeName = .usersSuccess - let users: [String: [Objects.User]] - - enum TypeName: String, Codable { - case usersSuccess = "UsersSuccess" - } - } -} - -extension Objects.UsersSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "users": - if let value = try container.decode([Objects.User]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - users = map["users"] - } -} - -extension Fields where TypeLock == Objects.UsersSuccess { - func users(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "users", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.users[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UsersSuccess = Selection -} - -extension Objects { - struct UserSuccess { - let __typename: TypeName = .userSuccess - let user: [String: Objects.User] - - enum TypeName: String, Codable { - case userSuccess = "UserSuccess" - } - } -} - -extension Objects.UserSuccess: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { case "user": if let value = try container.decode(Objects.User?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) @@ -15343,131 +15464,51 @@ extension Objects.UserSuccess: Decodable { } } - user = map["user"] - } -} - -extension Fields where TypeLock == Objects.UserSuccess { - func user(selection: Selection) throws -> Type { - let field = GraphQLField.composite( - name: "user", - arguments: [], - selection: selection.selection - ) - select(field) - - switch response { - case let .decoding(data): - if let data = data.user[field.alias!] { - return try selection.decode(data: data) - } - throw HttpError.badpayload - case .mocking: - return selection.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UserSuccess = Selection -} - -// MARK: - Interfaces - -enum Interfaces {} - -// MARK: - Unions - -enum Unions {} -extension Unions { - struct AddPopularReadResult { - let __typename: TypeName - let errorCodes: [String: [Enums.AddPopularReadErrorCode]] - let pageId: [String: String] - - enum TypeName: String, Codable { - case addPopularReadError = "AddPopularReadError" - case addPopularReadSuccess = "AddPopularReadSuccess" - } - } -} - -extension Unions.AddPopularReadResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.AddPopularReadErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "pageId": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) errorCodes = map["errorCodes"] - pageId = map["pageId"] + user = map["user"] } } -extension Fields where TypeLock == Unions.AddPopularReadResult { - func on(addPopularReadError: Selection, addPopularReadSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "AddPopularReadError", selection: addPopularReadError.selection), GraphQLField.fragment(type: "AddPopularReadSuccess", selection: addPopularReadSuccess.selection)]) +extension Fields where TypeLock == Unions.UserResult { + func on(userSuccess: Selection, userError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "UserSuccess", selection: userSuccess.selection), GraphQLField.fragment(type: "UserError", selection: userError.selection)]) switch response { case let .decoding(data): switch data.__typename { - case .addPopularReadError: - let data = Objects.AddPopularReadError(errorCodes: data.errorCodes) - return try addPopularReadError.decode(data: data) - case .addPopularReadSuccess: - let data = Objects.AddPopularReadSuccess(pageId: data.pageId) - return try addPopularReadSuccess.decode(data: data) + case .userSuccess: + let data = Objects.UserSuccess(user: data.user) + return try userSuccess.decode(data: data) + case .userError: + let data = Objects.UserError(errorCodes: data.errorCodes) + return try userError.decode(data: data) } case .mocking: - return addPopularReadError.mock() + return userSuccess.mock() } } } extension Selection where TypeLock == Never, Type == Never { - typealias AddPopularReadResult = Selection + typealias UserResult = Selection } extension Unions { - struct ArchiveLinkResult { + struct UsersResult { let __typename: TypeName - let errorCodes: [String: [Enums.ArchiveLinkErrorCode]] - let linkId: [String: String] - let message: [String: String] + let errorCodes: [String: [Enums.UsersErrorCode]] + let users: [String: [Objects.User]] enum TypeName: String, Codable { - case archiveLinkError = "ArchiveLinkError" - case archiveLinkSuccess = "ArchiveLinkSuccess" + case usersSuccess = "UsersSuccess" + case usersError = "UsersError" } } } -extension Unions.ArchiveLinkResult: Decodable { +extension Unions.UsersResult: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -15480,11 +15521,229 @@ extension Unions.ArchiveLinkResult: Decodable { switch field { case "errorCodes": - if let value = try container.decode([Enums.ArchiveLinkErrorCode]?.self, forKey: codingKey) { + if let value = try container.decode([Enums.UsersErrorCode]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - case "linkId": - if let value = try container.decode(String?.self, forKey: codingKey) { + case "users": + if let value = try container.decode([Objects.User]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + users = map["users"] + } +} + +extension Fields where TypeLock == Unions.UsersResult { + func on(usersSuccess: Selection, usersError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "UsersSuccess", selection: usersSuccess.selection), GraphQLField.fragment(type: "UsersError", selection: usersError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .usersSuccess: + let data = Objects.UsersSuccess(users: data.users) + return try usersSuccess.decode(data: data) + case .usersError: + let data = Objects.UsersError(errorCodes: data.errorCodes) + return try usersError.decode(data: data) + } + case .mocking: + return usersSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UsersResult = Selection +} + +extension Unions { + struct LoginResult { + let __typename: TypeName + let errorCodes: [String: [Enums.LoginErrorCode]] + let me: [String: Objects.User] + + enum TypeName: String, Codable { + case loginSuccess = "LoginSuccess" + case loginError = "LoginError" + } + } +} + +extension Unions.LoginResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.LoginErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "me": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + me = map["me"] + } +} + +extension Fields where TypeLock == Unions.LoginResult { + func on(loginSuccess: Selection, loginError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "LoginSuccess", selection: loginSuccess.selection), GraphQLField.fragment(type: "LoginError", selection: loginError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .loginSuccess: + let data = Objects.LoginSuccess(me: data.me) + return try loginSuccess.decode(data: data) + case .loginError: + let data = Objects.LoginError(errorCodes: data.errorCodes) + return try loginError.decode(data: data) + } + case .mocking: + return loginSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias LoginResult = Selection +} + +extension Unions { + struct GoogleSignupResult { + let __typename: TypeName + let errorCodes: [String: [Enums.SignupErrorCode?]] + let me: [String: Objects.User] + + enum TypeName: String, Codable { + case googleSignupSuccess = "GoogleSignupSuccess" + case googleSignupError = "GoogleSignupError" + } + } +} + +extension Unions.GoogleSignupResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SignupErrorCode?]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "me": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + me = map["me"] + } +} + +extension Fields where TypeLock == Unions.GoogleSignupResult { + func on(googleSignupSuccess: Selection, googleSignupError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "GoogleSignupSuccess", selection: googleSignupSuccess.selection), GraphQLField.fragment(type: "GoogleSignupError", selection: googleSignupError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .googleSignupSuccess: + let data = Objects.GoogleSignupSuccess(me: data.me) + return try googleSignupSuccess.decode(data: data) + case .googleSignupError: + let data = Objects.GoogleSignupError(errorCodes: data.errorCodes) + return try googleSignupError.decode(data: data) + } + case .mocking: + return googleSignupSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias GoogleSignupResult = Selection +} + +extension Unions { + struct LogOutResult { + let __typename: TypeName + let errorCodes: [String: [Enums.LogOutErrorCode]] + let message: [String: String] + + enum TypeName: String, Codable { + case logOutSuccess = "LogOutSuccess" + case logOutError = "LogOutError" + } + } +} + +extension Unions.LogOutResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.LogOutErrorCode]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } case "message": @@ -15504,33 +15763,180 @@ extension Unions.ArchiveLinkResult: Decodable { __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) errorCodes = map["errorCodes"] - linkId = map["linkId"] message = map["message"] } } -extension Fields where TypeLock == Unions.ArchiveLinkResult { - func on(archiveLinkError: Selection, archiveLinkSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "ArchiveLinkError", selection: archiveLinkError.selection), GraphQLField.fragment(type: "ArchiveLinkSuccess", selection: archiveLinkSuccess.selection)]) +extension Fields where TypeLock == Unions.LogOutResult { + func on(logOutSuccess: Selection, logOutError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "LogOutSuccess", selection: logOutSuccess.selection), GraphQLField.fragment(type: "LogOutError", selection: logOutError.selection)]) switch response { case let .decoding(data): switch data.__typename { - case .archiveLinkError: - let data = Objects.ArchiveLinkError(errorCodes: data.errorCodes, message: data.message) - return try archiveLinkError.decode(data: data) - case .archiveLinkSuccess: - let data = Objects.ArchiveLinkSuccess(linkId: data.linkId, message: data.message) - return try archiveLinkSuccess.decode(data: data) + case .logOutSuccess: + let data = Objects.LogOutSuccess(message: data.message) + return try logOutSuccess.decode(data: data) + case .logOutError: + let data = Objects.LogOutError(errorCodes: data.errorCodes) + return try logOutError.decode(data: data) } case .mocking: - return archiveLinkError.mock() + return logOutSuccess.mock() } } } extension Selection where TypeLock == Never, Type == Never { - typealias ArchiveLinkResult = Selection + typealias LogOutResult = Selection +} + +extension Unions { + struct UpdateUserResult { + let __typename: TypeName + let errorCodes: [String: [Enums.UpdateUserErrorCode]] + let user: [String: Objects.User] + + enum TypeName: String, Codable { + case updateUserSuccess = "UpdateUserSuccess" + case updateUserError = "UpdateUserError" + } + } +} + +extension Unions.UpdateUserResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdateUserErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "user": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + user = map["user"] + } +} + +extension Fields where TypeLock == Unions.UpdateUserResult { + func on(updateUserSuccess: Selection, updateUserError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "UpdateUserSuccess", selection: updateUserSuccess.selection), GraphQLField.fragment(type: "UpdateUserError", selection: updateUserError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .updateUserSuccess: + let data = Objects.UpdateUserSuccess(user: data.user) + return try updateUserSuccess.decode(data: data) + case .updateUserError: + let data = Objects.UpdateUserError(errorCodes: data.errorCodes) + return try updateUserError.decode(data: data) + } + case .mocking: + return updateUserSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateUserResult = Selection +} + +extension Unions { + struct UpdateUserProfileResult { + let __typename: TypeName + let errorCodes: [String: [Enums.UpdateUserProfileErrorCode]] + let user: [String: Objects.User] + + enum TypeName: String, Codable { + case updateUserProfileSuccess = "UpdateUserProfileSuccess" + case updateUserProfileError = "UpdateUserProfileError" + } + } +} + +extension Unions.UpdateUserProfileResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdateUserProfileErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "user": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + user = map["user"] + } +} + +extension Fields where TypeLock == Unions.UpdateUserProfileResult { + func on(updateUserProfileSuccess: Selection, updateUserProfileError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "UpdateUserProfileSuccess", selection: updateUserProfileSuccess.selection), GraphQLField.fragment(type: "UpdateUserProfileError", selection: updateUserProfileError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .updateUserProfileSuccess: + let data = Objects.UpdateUserProfileSuccess(user: data.user) + return try updateUserProfileSuccess.decode(data: data) + case .updateUserProfileError: + let data = Objects.UpdateUserProfileError(errorCodes: data.errorCodes) + return try updateUserProfileError.decode(data: data) + } + case .mocking: + return updateUserProfileSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateUserProfileResult = Selection } extension Unions { @@ -15540,8 +15946,8 @@ extension Unions { let errorCodes: [String: [Enums.ArticleErrorCode]] enum TypeName: String, Codable { - case articleError = "ArticleError" case articleSuccess = "ArticleSuccess" + case articleError = "ArticleError" } } } @@ -15584,21 +15990,21 @@ extension Unions.ArticleResult: Decodable { } extension Fields where TypeLock == Unions.ArticleResult { - func on(articleError: Selection, articleSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "ArticleError", selection: articleError.selection), GraphQLField.fragment(type: "ArticleSuccess", selection: articleSuccess.selection)]) + func on(articleSuccess: Selection, articleError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "ArticleSuccess", selection: articleSuccess.selection), GraphQLField.fragment(type: "ArticleError", selection: articleError.selection)]) switch response { case let .decoding(data): switch data.__typename { - case .articleError: - let data = Objects.ArticleError(errorCodes: data.errorCodes) - return try articleError.decode(data: data) case .articleSuccess: let data = Objects.ArticleSuccess(article: data.article) return try articleSuccess.decode(data: data) + case .articleError: + let data = Objects.ArticleError(errorCodes: data.errorCodes) + return try articleError.decode(data: data) } case .mocking: - return articleError.mock() + return articleSuccess.mock() } } } @@ -15608,19 +16014,19 @@ extension Selection where TypeLock == Never, Type == Never { } extension Unions { - struct ArticleSavingRequestResult { + struct SharedArticleResult { let __typename: TypeName - let articleSavingRequest: [String: Objects.ArticleSavingRequest] - let errorCodes: [String: [Enums.ArticleSavingRequestErrorCode]] + let article: [String: Objects.Article] + let errorCodes: [String: [Enums.SharedArticleErrorCode]] enum TypeName: String, Codable { - case articleSavingRequestError = "ArticleSavingRequestError" - case articleSavingRequestSuccess = "ArticleSavingRequestSuccess" + case sharedArticleSuccess = "SharedArticleSuccess" + case sharedArticleError = "SharedArticleError" } } } -extension Unions.ArticleSavingRequestResult: Decodable { +extension Unions.SharedArticleResult: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -15632,12 +16038,12 @@ extension Unions.ArticleSavingRequestResult: Decodable { let field = GraphQLField.getFieldNameFromAlias(alias) switch field { - case "articleSavingRequest": - if let value = try container.decode(Objects.ArticleSavingRequest?.self, forKey: codingKey) { + case "article": + if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } case "errorCodes": - if let value = try container.decode([Enums.ArticleSavingRequestErrorCode]?.self, forKey: codingKey) { + if let value = try container.decode([Enums.SharedArticleErrorCode]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } default: @@ -15652,33 +16058,33 @@ extension Unions.ArticleSavingRequestResult: Decodable { __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - articleSavingRequest = map["articleSavingRequest"] + article = map["article"] errorCodes = map["errorCodes"] } } -extension Fields where TypeLock == Unions.ArticleSavingRequestResult { - func on(articleSavingRequestError: Selection, articleSavingRequestSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "ArticleSavingRequestError", selection: articleSavingRequestError.selection), GraphQLField.fragment(type: "ArticleSavingRequestSuccess", selection: articleSavingRequestSuccess.selection)]) +extension Fields where TypeLock == Unions.SharedArticleResult { + func on(sharedArticleSuccess: Selection, sharedArticleError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "SharedArticleSuccess", selection: sharedArticleSuccess.selection), GraphQLField.fragment(type: "SharedArticleError", selection: sharedArticleError.selection)]) switch response { case let .decoding(data): switch data.__typename { - case .articleSavingRequestError: - let data = Objects.ArticleSavingRequestError(errorCodes: data.errorCodes) - return try articleSavingRequestError.decode(data: data) - case .articleSavingRequestSuccess: - let data = Objects.ArticleSavingRequestSuccess(articleSavingRequest: data.articleSavingRequest) - return try articleSavingRequestSuccess.decode(data: data) + case .sharedArticleSuccess: + let data = Objects.SharedArticleSuccess(article: data.article) + return try sharedArticleSuccess.decode(data: data) + case .sharedArticleError: + let data = Objects.SharedArticleError(errorCodes: data.errorCodes) + return try sharedArticleError.decode(data: data) } case .mocking: - return articleSavingRequestError.mock() + return sharedArticleSuccess.mock() } } } extension Selection where TypeLock == Never, Type == Never { - typealias ArticleSavingRequestResult = Selection + typealias SharedArticleResult = Selection } extension Unions { @@ -15689,8 +16095,8 @@ extension Unions { let pageInfo: [String: Objects.PageInfo] enum TypeName: String, Codable { - case articlesError = "ArticlesError" case articlesSuccess = "ArticlesSuccess" + case articlesError = "ArticlesError" } } } @@ -15738,21 +16144,21 @@ extension Unions.ArticlesResult: Decodable { } extension Fields where TypeLock == Unions.ArticlesResult { - func on(articlesError: Selection, articlesSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "ArticlesError", selection: articlesError.selection), GraphQLField.fragment(type: "ArticlesSuccess", selection: articlesSuccess.selection)]) + func on(articlesSuccess: Selection, articlesError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "ArticlesSuccess", selection: articlesSuccess.selection), GraphQLField.fragment(type: "ArticlesError", selection: articlesError.selection)]) switch response { case let .decoding(data): switch data.__typename { - case .articlesError: - let data = Objects.ArticlesError(errorCodes: data.errorCodes) - return try articlesError.decode(data: data) case .articlesSuccess: let data = Objects.ArticlesSuccess(edges: data.edges, pageInfo: data.pageInfo) return try articlesSuccess.decode(data: data) + case .articlesError: + let data = Objects.ArticlesError(errorCodes: data.errorCodes) + return try articlesError.decode(data: data) } case .mocking: - return articlesError.mock() + return articlesSuccess.mock() } } } @@ -15761,3766 +16167,6 @@ extension Selection where TypeLock == Never, Type == Never { typealias ArticlesResult = Selection } -extension Unions { - struct CreateArticleResult { - let __typename: TypeName - let created: [String: Bool] - let createdArticle: [String: Objects.Article] - let errorCodes: [String: [Enums.CreateArticleErrorCode]] - let user: [String: Objects.User] - - enum TypeName: String, Codable { - case createArticleError = "CreateArticleError" - case createArticleSuccess = "CreateArticleSuccess" - } - } -} - -extension Unions.CreateArticleResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "created": - if let value = try container.decode(Bool?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "createdArticle": - if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "errorCodes": - if let value = try container.decode([Enums.CreateArticleErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "user": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - created = map["created"] - createdArticle = map["createdArticle"] - errorCodes = map["errorCodes"] - user = map["user"] - } -} - -extension Fields where TypeLock == Unions.CreateArticleResult { - func on(createArticleError: Selection, createArticleSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "CreateArticleError", selection: createArticleError.selection), GraphQLField.fragment(type: "CreateArticleSuccess", selection: createArticleSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .createArticleError: - let data = Objects.CreateArticleError(errorCodes: data.errorCodes) - return try createArticleError.decode(data: data) - case .createArticleSuccess: - let data = Objects.CreateArticleSuccess(created: data.created, createdArticle: data.createdArticle, user: data.user) - return try createArticleSuccess.decode(data: data) - } - case .mocking: - return createArticleError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateArticleResult = Selection -} - -extension Unions { - struct CreateArticleSavingRequestResult { - let __typename: TypeName - let articleSavingRequest: [String: Objects.ArticleSavingRequest] - let errorCodes: [String: [Enums.CreateArticleSavingRequestErrorCode]] - - enum TypeName: String, Codable { - case createArticleSavingRequestError = "CreateArticleSavingRequestError" - case createArticleSavingRequestSuccess = "CreateArticleSavingRequestSuccess" - } - } -} - -extension Unions.CreateArticleSavingRequestResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "articleSavingRequest": - if let value = try container.decode(Objects.ArticleSavingRequest?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "errorCodes": - if let value = try container.decode([Enums.CreateArticleSavingRequestErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - articleSavingRequest = map["articleSavingRequest"] - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Unions.CreateArticleSavingRequestResult { - func on(createArticleSavingRequestError: Selection, createArticleSavingRequestSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "CreateArticleSavingRequestError", selection: createArticleSavingRequestError.selection), GraphQLField.fragment(type: "CreateArticleSavingRequestSuccess", selection: createArticleSavingRequestSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .createArticleSavingRequestError: - let data = Objects.CreateArticleSavingRequestError(errorCodes: data.errorCodes) - return try createArticleSavingRequestError.decode(data: data) - case .createArticleSavingRequestSuccess: - let data = Objects.CreateArticleSavingRequestSuccess(articleSavingRequest: data.articleSavingRequest) - return try createArticleSavingRequestSuccess.decode(data: data) - } - case .mocking: - return createArticleSavingRequestError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateArticleSavingRequestResult = Selection -} - -extension Unions { - struct CreateHighlightReplyResult { - let __typename: TypeName - let errorCodes: [String: [Enums.CreateHighlightReplyErrorCode]] - let highlightReply: [String: Objects.HighlightReply] - - enum TypeName: String, Codable { - case createHighlightReplyError = "CreateHighlightReplyError" - case createHighlightReplySuccess = "CreateHighlightReplySuccess" - } - } -} - -extension Unions.CreateHighlightReplyResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.CreateHighlightReplyErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "highlightReply": - if let value = try container.decode(Objects.HighlightReply?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - highlightReply = map["highlightReply"] - } -} - -extension Fields where TypeLock == Unions.CreateHighlightReplyResult { - func on(createHighlightReplyError: Selection, createHighlightReplySuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "CreateHighlightReplyError", selection: createHighlightReplyError.selection), GraphQLField.fragment(type: "CreateHighlightReplySuccess", selection: createHighlightReplySuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .createHighlightReplyError: - let data = Objects.CreateHighlightReplyError(errorCodes: data.errorCodes) - return try createHighlightReplyError.decode(data: data) - case .createHighlightReplySuccess: - let data = Objects.CreateHighlightReplySuccess(highlightReply: data.highlightReply) - return try createHighlightReplySuccess.decode(data: data) - } - case .mocking: - return createHighlightReplyError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateHighlightReplyResult = Selection -} - -extension Unions { - struct CreateHighlightResult { - let __typename: TypeName - let errorCodes: [String: [Enums.CreateHighlightErrorCode]] - let highlight: [String: Objects.Highlight] - - enum TypeName: String, Codable { - case createHighlightError = "CreateHighlightError" - case createHighlightSuccess = "CreateHighlightSuccess" - } - } -} - -extension Unions.CreateHighlightResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.CreateHighlightErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "highlight": - if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - highlight = map["highlight"] - } -} - -extension Fields where TypeLock == Unions.CreateHighlightResult { - func on(createHighlightError: Selection, createHighlightSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "CreateHighlightError", selection: createHighlightError.selection), GraphQLField.fragment(type: "CreateHighlightSuccess", selection: createHighlightSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .createHighlightError: - let data = Objects.CreateHighlightError(errorCodes: data.errorCodes) - return try createHighlightError.decode(data: data) - case .createHighlightSuccess: - let data = Objects.CreateHighlightSuccess(highlight: data.highlight) - return try createHighlightSuccess.decode(data: data) - } - case .mocking: - return createHighlightError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateHighlightResult = Selection -} - -extension Unions { - struct CreateLabelResult { - let __typename: TypeName - let errorCodes: [String: [Enums.CreateLabelErrorCode]] - let label: [String: Objects.Label] - - enum TypeName: String, Codable { - case createLabelError = "CreateLabelError" - case createLabelSuccess = "CreateLabelSuccess" - } - } -} - -extension Unions.CreateLabelResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.CreateLabelErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "label": - if let value = try container.decode(Objects.Label?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - label = map["label"] - } -} - -extension Fields where TypeLock == Unions.CreateLabelResult { - func on(createLabelError: Selection, createLabelSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "CreateLabelError", selection: createLabelError.selection), GraphQLField.fragment(type: "CreateLabelSuccess", selection: createLabelSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .createLabelError: - let data = Objects.CreateLabelError(errorCodes: data.errorCodes) - return try createLabelError.decode(data: data) - case .createLabelSuccess: - let data = Objects.CreateLabelSuccess(label: data.label) - return try createLabelSuccess.decode(data: data) - } - case .mocking: - return createLabelError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateLabelResult = Selection -} - -extension Unions { - struct CreateNewsletterEmailResult { - let __typename: TypeName - let errorCodes: [String: [Enums.CreateNewsletterEmailErrorCode]] - let newsletterEmail: [String: Objects.NewsletterEmail] - - enum TypeName: String, Codable { - case createNewsletterEmailError = "CreateNewsletterEmailError" - case createNewsletterEmailSuccess = "CreateNewsletterEmailSuccess" - } - } -} - -extension Unions.CreateNewsletterEmailResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.CreateNewsletterEmailErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "newsletterEmail": - if let value = try container.decode(Objects.NewsletterEmail?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - newsletterEmail = map["newsletterEmail"] - } -} - -extension Fields where TypeLock == Unions.CreateNewsletterEmailResult { - func on(createNewsletterEmailError: Selection, createNewsletterEmailSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "CreateNewsletterEmailError", selection: createNewsletterEmailError.selection), GraphQLField.fragment(type: "CreateNewsletterEmailSuccess", selection: createNewsletterEmailSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .createNewsletterEmailError: - let data = Objects.CreateNewsletterEmailError(errorCodes: data.errorCodes) - return try createNewsletterEmailError.decode(data: data) - case .createNewsletterEmailSuccess: - let data = Objects.CreateNewsletterEmailSuccess(newsletterEmail: data.newsletterEmail) - return try createNewsletterEmailSuccess.decode(data: data) - } - case .mocking: - return createNewsletterEmailError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateNewsletterEmailResult = Selection -} - -extension Unions { - struct CreateReactionResult { - let __typename: TypeName - let errorCodes: [String: [Enums.CreateReactionErrorCode]] - let reaction: [String: Objects.Reaction] - - enum TypeName: String, Codable { - case createReactionError = "CreateReactionError" - case createReactionSuccess = "CreateReactionSuccess" - } - } -} - -extension Unions.CreateReactionResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.CreateReactionErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "reaction": - if let value = try container.decode(Objects.Reaction?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - reaction = map["reaction"] - } -} - -extension Fields where TypeLock == Unions.CreateReactionResult { - func on(createReactionError: Selection, createReactionSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "CreateReactionError", selection: createReactionError.selection), GraphQLField.fragment(type: "CreateReactionSuccess", selection: createReactionSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .createReactionError: - let data = Objects.CreateReactionError(errorCodes: data.errorCodes) - return try createReactionError.decode(data: data) - case .createReactionSuccess: - let data = Objects.CreateReactionSuccess(reaction: data.reaction) - return try createReactionSuccess.decode(data: data) - } - case .mocking: - return createReactionError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateReactionResult = Selection -} - -extension Unions { - struct CreateReminderResult { - let __typename: TypeName - let errorCodes: [String: [Enums.CreateReminderErrorCode]] - let reminder: [String: Objects.Reminder] - - enum TypeName: String, Codable { - case createReminderError = "CreateReminderError" - case createReminderSuccess = "CreateReminderSuccess" - } - } -} - -extension Unions.CreateReminderResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.CreateReminderErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "reminder": - if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - reminder = map["reminder"] - } -} - -extension Fields where TypeLock == Unions.CreateReminderResult { - func on(createReminderError: Selection, createReminderSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "CreateReminderError", selection: createReminderError.selection), GraphQLField.fragment(type: "CreateReminderSuccess", selection: createReminderSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .createReminderError: - let data = Objects.CreateReminderError(errorCodes: data.errorCodes) - return try createReminderError.decode(data: data) - case .createReminderSuccess: - let data = Objects.CreateReminderSuccess(reminder: data.reminder) - return try createReminderSuccess.decode(data: data) - } - case .mocking: - return createReminderError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias CreateReminderResult = Selection -} - -extension Unions { - struct DeleteHighlightReplyResult { - let __typename: TypeName - let errorCodes: [String: [Enums.DeleteHighlightReplyErrorCode]] - let highlightReply: [String: Objects.HighlightReply] - - enum TypeName: String, Codable { - case deleteHighlightReplyError = "DeleteHighlightReplyError" - case deleteHighlightReplySuccess = "DeleteHighlightReplySuccess" - } - } -} - -extension Unions.DeleteHighlightReplyResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.DeleteHighlightReplyErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "highlightReply": - if let value = try container.decode(Objects.HighlightReply?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - highlightReply = map["highlightReply"] - } -} - -extension Fields where TypeLock == Unions.DeleteHighlightReplyResult { - func on(deleteHighlightReplyError: Selection, deleteHighlightReplySuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "DeleteHighlightReplyError", selection: deleteHighlightReplyError.selection), GraphQLField.fragment(type: "DeleteHighlightReplySuccess", selection: deleteHighlightReplySuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .deleteHighlightReplyError: - let data = Objects.DeleteHighlightReplyError(errorCodes: data.errorCodes) - return try deleteHighlightReplyError.decode(data: data) - case .deleteHighlightReplySuccess: - let data = Objects.DeleteHighlightReplySuccess(highlightReply: data.highlightReply) - return try deleteHighlightReplySuccess.decode(data: data) - } - case .mocking: - return deleteHighlightReplyError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteHighlightReplyResult = Selection -} - -extension Unions { - struct DeleteHighlightResult { - let __typename: TypeName - let errorCodes: [String: [Enums.DeleteHighlightErrorCode]] - let highlight: [String: Objects.Highlight] - - enum TypeName: String, Codable { - case deleteHighlightError = "DeleteHighlightError" - case deleteHighlightSuccess = "DeleteHighlightSuccess" - } - } -} - -extension Unions.DeleteHighlightResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.DeleteHighlightErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "highlight": - if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - highlight = map["highlight"] - } -} - -extension Fields where TypeLock == Unions.DeleteHighlightResult { - func on(deleteHighlightError: Selection, deleteHighlightSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "DeleteHighlightError", selection: deleteHighlightError.selection), GraphQLField.fragment(type: "DeleteHighlightSuccess", selection: deleteHighlightSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .deleteHighlightError: - let data = Objects.DeleteHighlightError(errorCodes: data.errorCodes) - return try deleteHighlightError.decode(data: data) - case .deleteHighlightSuccess: - let data = Objects.DeleteHighlightSuccess(highlight: data.highlight) - return try deleteHighlightSuccess.decode(data: data) - } - case .mocking: - return deleteHighlightError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteHighlightResult = Selection -} - -extension Unions { - struct DeleteLabelResult { - let __typename: TypeName - let errorCodes: [String: [Enums.DeleteLabelErrorCode]] - let label: [String: Objects.Label] - - enum TypeName: String, Codable { - case deleteLabelError = "DeleteLabelError" - case deleteLabelSuccess = "DeleteLabelSuccess" - } - } -} - -extension Unions.DeleteLabelResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.DeleteLabelErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "label": - if let value = try container.decode(Objects.Label?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - label = map["label"] - } -} - -extension Fields where TypeLock == Unions.DeleteLabelResult { - func on(deleteLabelError: Selection, deleteLabelSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "DeleteLabelError", selection: deleteLabelError.selection), GraphQLField.fragment(type: "DeleteLabelSuccess", selection: deleteLabelSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .deleteLabelError: - let data = Objects.DeleteLabelError(errorCodes: data.errorCodes) - return try deleteLabelError.decode(data: data) - case .deleteLabelSuccess: - let data = Objects.DeleteLabelSuccess(label: data.label) - return try deleteLabelSuccess.decode(data: data) - } - case .mocking: - return deleteLabelError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteLabelResult = Selection -} - -extension Unions { - struct DeleteNewsletterEmailResult { - let __typename: TypeName - let errorCodes: [String: [Enums.DeleteNewsletterEmailErrorCode]] - let newsletterEmail: [String: Objects.NewsletterEmail] - - enum TypeName: String, Codable { - case deleteNewsletterEmailError = "DeleteNewsletterEmailError" - case deleteNewsletterEmailSuccess = "DeleteNewsletterEmailSuccess" - } - } -} - -extension Unions.DeleteNewsletterEmailResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.DeleteNewsletterEmailErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "newsletterEmail": - if let value = try container.decode(Objects.NewsletterEmail?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - newsletterEmail = map["newsletterEmail"] - } -} - -extension Fields where TypeLock == Unions.DeleteNewsletterEmailResult { - func on(deleteNewsletterEmailError: Selection, deleteNewsletterEmailSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "DeleteNewsletterEmailError", selection: deleteNewsletterEmailError.selection), GraphQLField.fragment(type: "DeleteNewsletterEmailSuccess", selection: deleteNewsletterEmailSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .deleteNewsletterEmailError: - let data = Objects.DeleteNewsletterEmailError(errorCodes: data.errorCodes) - return try deleteNewsletterEmailError.decode(data: data) - case .deleteNewsletterEmailSuccess: - let data = Objects.DeleteNewsletterEmailSuccess(newsletterEmail: data.newsletterEmail) - return try deleteNewsletterEmailSuccess.decode(data: data) - } - case .mocking: - return deleteNewsletterEmailError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteNewsletterEmailResult = Selection -} - -extension Unions { - struct DeleteReactionResult { - let __typename: TypeName - let errorCodes: [String: [Enums.DeleteReactionErrorCode]] - let reaction: [String: Objects.Reaction] - - enum TypeName: String, Codable { - case deleteReactionError = "DeleteReactionError" - case deleteReactionSuccess = "DeleteReactionSuccess" - } - } -} - -extension Unions.DeleteReactionResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.DeleteReactionErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "reaction": - if let value = try container.decode(Objects.Reaction?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - reaction = map["reaction"] - } -} - -extension Fields where TypeLock == Unions.DeleteReactionResult { - func on(deleteReactionError: Selection, deleteReactionSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "DeleteReactionError", selection: deleteReactionError.selection), GraphQLField.fragment(type: "DeleteReactionSuccess", selection: deleteReactionSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .deleteReactionError: - let data = Objects.DeleteReactionError(errorCodes: data.errorCodes) - return try deleteReactionError.decode(data: data) - case .deleteReactionSuccess: - let data = Objects.DeleteReactionSuccess(reaction: data.reaction) - return try deleteReactionSuccess.decode(data: data) - } - case .mocking: - return deleteReactionError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteReactionResult = Selection -} - -extension Unions { - struct DeleteReminderResult { - let __typename: TypeName - let errorCodes: [String: [Enums.DeleteReminderErrorCode]] - let reminder: [String: Objects.Reminder] - - enum TypeName: String, Codable { - case deleteReminderError = "DeleteReminderError" - case deleteReminderSuccess = "DeleteReminderSuccess" - } - } -} - -extension Unions.DeleteReminderResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.DeleteReminderErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "reminder": - if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - reminder = map["reminder"] - } -} - -extension Fields where TypeLock == Unions.DeleteReminderResult { - func on(deleteReminderError: Selection, deleteReminderSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "DeleteReminderError", selection: deleteReminderError.selection), GraphQLField.fragment(type: "DeleteReminderSuccess", selection: deleteReminderSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .deleteReminderError: - let data = Objects.DeleteReminderError(errorCodes: data.errorCodes) - return try deleteReminderError.decode(data: data) - case .deleteReminderSuccess: - let data = Objects.DeleteReminderSuccess(reminder: data.reminder) - return try deleteReminderSuccess.decode(data: data) - } - case .mocking: - return deleteReminderError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias DeleteReminderResult = Selection -} - -extension Unions { - struct FeedArticlesResult { - let __typename: TypeName - let edges: [String: [Objects.FeedArticleEdge]] - let errorCodes: [String: [Enums.FeedArticlesErrorCode]] - let pageInfo: [String: Objects.PageInfo] - - enum TypeName: String, Codable { - case feedArticlesError = "FeedArticlesError" - case feedArticlesSuccess = "FeedArticlesSuccess" - } - } -} - -extension Unions.FeedArticlesResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "edges": - if let value = try container.decode([Objects.FeedArticleEdge]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "errorCodes": - if let value = try container.decode([Enums.FeedArticlesErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "pageInfo": - if let value = try container.decode(Objects.PageInfo?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - edges = map["edges"] - errorCodes = map["errorCodes"] - pageInfo = map["pageInfo"] - } -} - -extension Fields where TypeLock == Unions.FeedArticlesResult { - func on(feedArticlesError: Selection, feedArticlesSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "FeedArticlesError", selection: feedArticlesError.selection), GraphQLField.fragment(type: "FeedArticlesSuccess", selection: feedArticlesSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .feedArticlesError: - let data = Objects.FeedArticlesError(errorCodes: data.errorCodes) - return try feedArticlesError.decode(data: data) - case .feedArticlesSuccess: - let data = Objects.FeedArticlesSuccess(edges: data.edges, pageInfo: data.pageInfo) - return try feedArticlesSuccess.decode(data: data) - } - case .mocking: - return feedArticlesError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias FeedArticlesResult = Selection -} - -extension Unions { - struct GenerateApiKeyResult { - let __typename: TypeName - let apiKey: [String: String] - let errorCodes: [String: [Enums.GenerateApiKeyErrorCode]] - - enum TypeName: String, Codable { - case generateApiKeyError = "GenerateApiKeyError" - case generateApiKeySuccess = "GenerateApiKeySuccess" - } - } -} - -extension Unions.GenerateApiKeyResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "apiKey": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "errorCodes": - if let value = try container.decode([Enums.GenerateApiKeyErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - apiKey = map["apiKey"] - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Unions.GenerateApiKeyResult { - func on(generateApiKeyError: Selection, generateApiKeySuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "GenerateApiKeyError", selection: generateApiKeyError.selection), GraphQLField.fragment(type: "GenerateApiKeySuccess", selection: generateApiKeySuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .generateApiKeyError: - let data = Objects.GenerateApiKeyError(errorCodes: data.errorCodes) - return try generateApiKeyError.decode(data: data) - case .generateApiKeySuccess: - let data = Objects.GenerateApiKeySuccess(apiKey: data.apiKey) - return try generateApiKeySuccess.decode(data: data) - } - case .mocking: - return generateApiKeyError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias GenerateApiKeyResult = Selection -} - -extension Unions { - struct GetFollowersResult { - let __typename: TypeName - let errorCodes: [String: [Enums.GetFollowersErrorCode]] - let followers: [String: [Objects.User]] - - enum TypeName: String, Codable { - case getFollowersError = "GetFollowersError" - case getFollowersSuccess = "GetFollowersSuccess" - } - } -} - -extension Unions.GetFollowersResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.GetFollowersErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "followers": - if let value = try container.decode([Objects.User]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - followers = map["followers"] - } -} - -extension Fields where TypeLock == Unions.GetFollowersResult { - func on(getFollowersError: Selection, getFollowersSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "GetFollowersError", selection: getFollowersError.selection), GraphQLField.fragment(type: "GetFollowersSuccess", selection: getFollowersSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .getFollowersError: - let data = Objects.GetFollowersError(errorCodes: data.errorCodes) - return try getFollowersError.decode(data: data) - case .getFollowersSuccess: - let data = Objects.GetFollowersSuccess(followers: data.followers) - return try getFollowersSuccess.decode(data: data) - } - case .mocking: - return getFollowersError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias GetFollowersResult = Selection -} - -extension Unions { - struct GetFollowingResult { - let __typename: TypeName - let errorCodes: [String: [Enums.GetFollowingErrorCode]] - let following: [String: [Objects.User]] - - enum TypeName: String, Codable { - case getFollowingError = "GetFollowingError" - case getFollowingSuccess = "GetFollowingSuccess" - } - } -} - -extension Unions.GetFollowingResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.GetFollowingErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "following": - if let value = try container.decode([Objects.User]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - following = map["following"] - } -} - -extension Fields where TypeLock == Unions.GetFollowingResult { - func on(getFollowingError: Selection, getFollowingSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "GetFollowingError", selection: getFollowingError.selection), GraphQLField.fragment(type: "GetFollowingSuccess", selection: getFollowingSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .getFollowingError: - let data = Objects.GetFollowingError(errorCodes: data.errorCodes) - return try getFollowingError.decode(data: data) - case .getFollowingSuccess: - let data = Objects.GetFollowingSuccess(following: data.following) - return try getFollowingSuccess.decode(data: data) - } - case .mocking: - return getFollowingError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias GetFollowingResult = Selection -} - -extension Unions { - struct GetUserPersonalizationResult { - let __typename: TypeName - let errorCodes: [String: [Enums.GetUserPersonalizationErrorCode]] - let userPersonalization: [String: Objects.UserPersonalization] - - enum TypeName: String, Codable { - case getUserPersonalizationError = "GetUserPersonalizationError" - case getUserPersonalizationSuccess = "GetUserPersonalizationSuccess" - } - } -} - -extension Unions.GetUserPersonalizationResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.GetUserPersonalizationErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "userPersonalization": - if let value = try container.decode(Objects.UserPersonalization?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - userPersonalization = map["userPersonalization"] - } -} - -extension Fields where TypeLock == Unions.GetUserPersonalizationResult { - func on(getUserPersonalizationError: Selection, getUserPersonalizationSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "GetUserPersonalizationError", selection: getUserPersonalizationError.selection), GraphQLField.fragment(type: "GetUserPersonalizationSuccess", selection: getUserPersonalizationSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .getUserPersonalizationError: - let data = Objects.GetUserPersonalizationError(errorCodes: data.errorCodes) - return try getUserPersonalizationError.decode(data: data) - case .getUserPersonalizationSuccess: - let data = Objects.GetUserPersonalizationSuccess(userPersonalization: data.userPersonalization) - return try getUserPersonalizationSuccess.decode(data: data) - } - case .mocking: - return getUserPersonalizationError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias GetUserPersonalizationResult = Selection -} - -extension Unions { - struct GoogleSignupResult { - let __typename: TypeName - let errorCodes: [String: [Enums.SignupErrorCode?]] - let me: [String: Objects.User] - - enum TypeName: String, Codable { - case googleSignupError = "GoogleSignupError" - case googleSignupSuccess = "GoogleSignupSuccess" - } - } -} - -extension Unions.GoogleSignupResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SignupErrorCode?]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "me": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - me = map["me"] - } -} - -extension Fields where TypeLock == Unions.GoogleSignupResult { - func on(googleSignupError: Selection, googleSignupSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "GoogleSignupError", selection: googleSignupError.selection), GraphQLField.fragment(type: "GoogleSignupSuccess", selection: googleSignupSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .googleSignupError: - let data = Objects.GoogleSignupError(errorCodes: data.errorCodes) - return try googleSignupError.decode(data: data) - case .googleSignupSuccess: - let data = Objects.GoogleSignupSuccess(me: data.me) - return try googleSignupSuccess.decode(data: data) - } - case .mocking: - return googleSignupError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias GoogleSignupResult = Selection -} - -extension Unions { - struct LabelsResult { - let __typename: TypeName - let errorCodes: [String: [Enums.LabelsErrorCode]] - let labels: [String: [Objects.Label]] - - enum TypeName: String, Codable { - case labelsError = "LabelsError" - case labelsSuccess = "LabelsSuccess" - } - } -} - -extension Unions.LabelsResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.LabelsErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "labels": - if let value = try container.decode([Objects.Label]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - labels = map["labels"] - } -} - -extension Fields where TypeLock == Unions.LabelsResult { - func on(labelsError: Selection, labelsSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "LabelsError", selection: labelsError.selection), GraphQLField.fragment(type: "LabelsSuccess", selection: labelsSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .labelsError: - let data = Objects.LabelsError(errorCodes: data.errorCodes) - return try labelsError.decode(data: data) - case .labelsSuccess: - let data = Objects.LabelsSuccess(labels: data.labels) - return try labelsSuccess.decode(data: data) - } - case .mocking: - return labelsError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias LabelsResult = Selection -} - -extension Unions { - struct LoginResult { - let __typename: TypeName - let errorCodes: [String: [Enums.LoginErrorCode]] - let me: [String: Objects.User] - - enum TypeName: String, Codable { - case loginError = "LoginError" - case loginSuccess = "LoginSuccess" - } - } -} - -extension Unions.LoginResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.LoginErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "me": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - me = map["me"] - } -} - -extension Fields where TypeLock == Unions.LoginResult { - func on(loginError: Selection, loginSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "LoginError", selection: loginError.selection), GraphQLField.fragment(type: "LoginSuccess", selection: loginSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .loginError: - let data = Objects.LoginError(errorCodes: data.errorCodes) - return try loginError.decode(data: data) - case .loginSuccess: - let data = Objects.LoginSuccess(me: data.me) - return try loginSuccess.decode(data: data) - } - case .mocking: - return loginError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias LoginResult = Selection -} - -extension Unions { - struct LogOutResult { - let __typename: TypeName - let errorCodes: [String: [Enums.LogOutErrorCode]] - let message: [String: String] - - enum TypeName: String, Codable { - case logOutError = "LogOutError" - case logOutSuccess = "LogOutSuccess" - } - } -} - -extension Unions.LogOutResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.LogOutErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "message": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - message = map["message"] - } -} - -extension Fields where TypeLock == Unions.LogOutResult { - func on(logOutError: Selection, logOutSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "LogOutError", selection: logOutError.selection), GraphQLField.fragment(type: "LogOutSuccess", selection: logOutSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .logOutError: - let data = Objects.LogOutError(errorCodes: data.errorCodes) - return try logOutError.decode(data: data) - case .logOutSuccess: - let data = Objects.LogOutSuccess(message: data.message) - return try logOutSuccess.decode(data: data) - } - case .mocking: - return logOutError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias LogOutResult = Selection -} - -extension Unions { - struct MergeHighlightResult { - let __typename: TypeName - let errorCodes: [String: [Enums.MergeHighlightErrorCode]] - let highlight: [String: Objects.Highlight] - let overlapHighlightIdList: [String: [String]] - - enum TypeName: String, Codable { - case mergeHighlightError = "MergeHighlightError" - case mergeHighlightSuccess = "MergeHighlightSuccess" - } - } -} - -extension Unions.MergeHighlightResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.MergeHighlightErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "highlight": - if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "overlapHighlightIdList": - if let value = try container.decode([String]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - highlight = map["highlight"] - overlapHighlightIdList = map["overlapHighlightIdList"] - } -} - -extension Fields where TypeLock == Unions.MergeHighlightResult { - func on(mergeHighlightError: Selection, mergeHighlightSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "MergeHighlightError", selection: mergeHighlightError.selection), GraphQLField.fragment(type: "MergeHighlightSuccess", selection: mergeHighlightSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .mergeHighlightError: - let data = Objects.MergeHighlightError(errorCodes: data.errorCodes) - return try mergeHighlightError.decode(data: data) - case .mergeHighlightSuccess: - let data = Objects.MergeHighlightSuccess(highlight: data.highlight, overlapHighlightIdList: data.overlapHighlightIdList) - return try mergeHighlightSuccess.decode(data: data) - } - case .mocking: - return mergeHighlightError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias MergeHighlightResult = Selection -} - -extension Unions { - struct NewsletterEmailsResult { - let __typename: TypeName - let errorCodes: [String: [Enums.NewsletterEmailsErrorCode]] - let newsletterEmails: [String: [Objects.NewsletterEmail]] - - enum TypeName: String, Codable { - case newsletterEmailsError = "NewsletterEmailsError" - case newsletterEmailsSuccess = "NewsletterEmailsSuccess" - } - } -} - -extension Unions.NewsletterEmailsResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.NewsletterEmailsErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "newsletterEmails": - if let value = try container.decode([Objects.NewsletterEmail]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - newsletterEmails = map["newsletterEmails"] - } -} - -extension Fields where TypeLock == Unions.NewsletterEmailsResult { - func on(newsletterEmailsError: Selection, newsletterEmailsSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "NewsletterEmailsError", selection: newsletterEmailsError.selection), GraphQLField.fragment(type: "NewsletterEmailsSuccess", selection: newsletterEmailsSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .newsletterEmailsError: - let data = Objects.NewsletterEmailsError(errorCodes: data.errorCodes) - return try newsletterEmailsError.decode(data: data) - case .newsletterEmailsSuccess: - let data = Objects.NewsletterEmailsSuccess(newsletterEmails: data.newsletterEmails) - return try newsletterEmailsSuccess.decode(data: data) - } - case .mocking: - return newsletterEmailsError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias NewsletterEmailsResult = Selection -} - -extension Unions { - struct ReminderResult { - let __typename: TypeName - let errorCodes: [String: [Enums.ReminderErrorCode]] - let reminder: [String: Objects.Reminder] - - enum TypeName: String, Codable { - case reminderError = "ReminderError" - case reminderSuccess = "ReminderSuccess" - } - } -} - -extension Unions.ReminderResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.ReminderErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "reminder": - if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - reminder = map["reminder"] - } -} - -extension Fields where TypeLock == Unions.ReminderResult { - func on(reminderError: Selection, reminderSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "ReminderError", selection: reminderError.selection), GraphQLField.fragment(type: "ReminderSuccess", selection: reminderSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .reminderError: - let data = Objects.ReminderError(errorCodes: data.errorCodes) - return try reminderError.decode(data: data) - case .reminderSuccess: - let data = Objects.ReminderSuccess(reminder: data.reminder) - return try reminderSuccess.decode(data: data) - } - case .mocking: - return reminderError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias ReminderResult = Selection -} - -extension Unions { - struct SaveArticleReadingProgressResult { - let __typename: TypeName - let errorCodes: [String: [Enums.SaveArticleReadingProgressErrorCode]] - let updatedArticle: [String: Objects.Article] - - enum TypeName: String, Codable { - case saveArticleReadingProgressError = "SaveArticleReadingProgressError" - case saveArticleReadingProgressSuccess = "SaveArticleReadingProgressSuccess" - } - } -} - -extension Unions.SaveArticleReadingProgressResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SaveArticleReadingProgressErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "updatedArticle": - if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - updatedArticle = map["updatedArticle"] - } -} - -extension Fields where TypeLock == Unions.SaveArticleReadingProgressResult { - func on(saveArticleReadingProgressError: Selection, saveArticleReadingProgressSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "SaveArticleReadingProgressError", selection: saveArticleReadingProgressError.selection), GraphQLField.fragment(type: "SaveArticleReadingProgressSuccess", selection: saveArticleReadingProgressSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .saveArticleReadingProgressError: - let data = Objects.SaveArticleReadingProgressError(errorCodes: data.errorCodes) - return try saveArticleReadingProgressError.decode(data: data) - case .saveArticleReadingProgressSuccess: - let data = Objects.SaveArticleReadingProgressSuccess(updatedArticle: data.updatedArticle) - return try saveArticleReadingProgressSuccess.decode(data: data) - } - case .mocking: - return saveArticleReadingProgressError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SaveArticleReadingProgressResult = Selection -} - -extension Unions { - struct SaveResult { - let __typename: TypeName - let clientRequestId: [String: String] - let errorCodes: [String: [Enums.SaveErrorCode]] - let message: [String: String] - let url: [String: String] - - enum TypeName: String, Codable { - case saveError = "SaveError" - case saveSuccess = "SaveSuccess" - } - } -} - -extension Unions.SaveResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "clientRequestId": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "errorCodes": - if let value = try container.decode([Enums.SaveErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "message": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "url": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - clientRequestId = map["clientRequestId"] - errorCodes = map["errorCodes"] - message = map["message"] - url = map["url"] - } -} - -extension Fields where TypeLock == Unions.SaveResult { - func on(saveError: Selection, saveSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "SaveError", selection: saveError.selection), GraphQLField.fragment(type: "SaveSuccess", selection: saveSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .saveError: - let data = Objects.SaveError(errorCodes: data.errorCodes, message: data.message) - return try saveError.decode(data: data) - case .saveSuccess: - let data = Objects.SaveSuccess(clientRequestId: data.clientRequestId, url: data.url) - return try saveSuccess.decode(data: data) - } - case .mocking: - return saveError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SaveResult = Selection -} - -extension Unions { - struct SearchResult { - let __typename: TypeName - let edges: [String: [Objects.SearchItemEdge]] - let errorCodes: [String: [Enums.SearchErrorCode]] - let pageInfo: [String: Objects.PageInfo] - - enum TypeName: String, Codable { - case searchError = "SearchError" - case searchSuccess = "SearchSuccess" - } - } -} - -extension Unions.SearchResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "edges": - if let value = try container.decode([Objects.SearchItemEdge]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "errorCodes": - if let value = try container.decode([Enums.SearchErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "pageInfo": - if let value = try container.decode(Objects.PageInfo?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - edges = map["edges"] - errorCodes = map["errorCodes"] - pageInfo = map["pageInfo"] - } -} - -extension Fields where TypeLock == Unions.SearchResult { - func on(searchError: Selection, searchSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "SearchError", selection: searchError.selection), GraphQLField.fragment(type: "SearchSuccess", selection: searchSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .searchError: - let data = Objects.SearchError(errorCodes: data.errorCodes) - return try searchError.decode(data: data) - case .searchSuccess: - let data = Objects.SearchSuccess(edges: data.edges, pageInfo: data.pageInfo) - return try searchSuccess.decode(data: data) - } - case .mocking: - return searchError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SearchResult = Selection -} - -extension Unions { - struct SetBookmarkArticleResult { - let __typename: TypeName - let bookmarkedArticle: [String: Objects.Article] - let errorCodes: [String: [Enums.SetBookmarkArticleErrorCode]] - - enum TypeName: String, Codable { - case setBookmarkArticleError = "SetBookmarkArticleError" - case setBookmarkArticleSuccess = "SetBookmarkArticleSuccess" - } - } -} - -extension Unions.SetBookmarkArticleResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "bookmarkedArticle": - if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "errorCodes": - if let value = try container.decode([Enums.SetBookmarkArticleErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - bookmarkedArticle = map["bookmarkedArticle"] - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Unions.SetBookmarkArticleResult { - func on(setBookmarkArticleError: Selection, setBookmarkArticleSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "SetBookmarkArticleError", selection: setBookmarkArticleError.selection), GraphQLField.fragment(type: "SetBookmarkArticleSuccess", selection: setBookmarkArticleSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .setBookmarkArticleError: - let data = Objects.SetBookmarkArticleError(errorCodes: data.errorCodes) - return try setBookmarkArticleError.decode(data: data) - case .setBookmarkArticleSuccess: - let data = Objects.SetBookmarkArticleSuccess(bookmarkedArticle: data.bookmarkedArticle) - return try setBookmarkArticleSuccess.decode(data: data) - } - case .mocking: - return setBookmarkArticleError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetBookmarkArticleResult = Selection -} - -extension Unions { - struct SetDeviceTokenResult { - let __typename: TypeName - let deviceToken: [String: Objects.DeviceToken] - let errorCodes: [String: [Enums.SetDeviceTokenErrorCode]] - - enum TypeName: String, Codable { - case setDeviceTokenError = "SetDeviceTokenError" - case setDeviceTokenSuccess = "SetDeviceTokenSuccess" - } - } -} - -extension Unions.SetDeviceTokenResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "deviceToken": - if let value = try container.decode(Objects.DeviceToken?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "errorCodes": - if let value = try container.decode([Enums.SetDeviceTokenErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - deviceToken = map["deviceToken"] - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Unions.SetDeviceTokenResult { - func on(setDeviceTokenError: Selection, setDeviceTokenSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "SetDeviceTokenError", selection: setDeviceTokenError.selection), GraphQLField.fragment(type: "SetDeviceTokenSuccess", selection: setDeviceTokenSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .setDeviceTokenError: - let data = Objects.SetDeviceTokenError(errorCodes: data.errorCodes) - return try setDeviceTokenError.decode(data: data) - case .setDeviceTokenSuccess: - let data = Objects.SetDeviceTokenSuccess(deviceToken: data.deviceToken) - return try setDeviceTokenSuccess.decode(data: data) - } - case .mocking: - return setDeviceTokenError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetDeviceTokenResult = Selection -} - -extension Unions { - struct SetFollowResult { - let __typename: TypeName - let errorCodes: [String: [Enums.SetFollowErrorCode]] - let updatedUser: [String: Objects.User] - - enum TypeName: String, Codable { - case setFollowError = "SetFollowError" - case setFollowSuccess = "SetFollowSuccess" - } - } -} - -extension Unions.SetFollowResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SetFollowErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "updatedUser": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - updatedUser = map["updatedUser"] - } -} - -extension Fields where TypeLock == Unions.SetFollowResult { - func on(setFollowError: Selection, setFollowSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "SetFollowError", selection: setFollowError.selection), GraphQLField.fragment(type: "SetFollowSuccess", selection: setFollowSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .setFollowError: - let data = Objects.SetFollowError(errorCodes: data.errorCodes) - return try setFollowError.decode(data: data) - case .setFollowSuccess: - let data = Objects.SetFollowSuccess(updatedUser: data.updatedUser) - return try setFollowSuccess.decode(data: data) - } - case .mocking: - return setFollowError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetFollowResult = Selection -} - -extension Unions { - struct SetLabelsResult { - let __typename: TypeName - let errorCodes: [String: [Enums.SetLabelsErrorCode]] - let labels: [String: [Objects.Label]] - - enum TypeName: String, Codable { - case setLabelsError = "SetLabelsError" - case setLabelsSuccess = "SetLabelsSuccess" - } - } -} - -extension Unions.SetLabelsResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SetLabelsErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "labels": - if let value = try container.decode([Objects.Label]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - labels = map["labels"] - } -} - -extension Fields where TypeLock == Unions.SetLabelsResult { - func on(setLabelsError: Selection, setLabelsSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "SetLabelsError", selection: setLabelsError.selection), GraphQLField.fragment(type: "SetLabelsSuccess", selection: setLabelsSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .setLabelsError: - let data = Objects.SetLabelsError(errorCodes: data.errorCodes) - return try setLabelsError.decode(data: data) - case .setLabelsSuccess: - let data = Objects.SetLabelsSuccess(labels: data.labels) - return try setLabelsSuccess.decode(data: data) - } - case .mocking: - return setLabelsError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetLabelsResult = Selection -} - -extension Unions { - struct SetShareArticleResult { - let __typename: TypeName - let errorCodes: [String: [Enums.SetShareArticleErrorCode]] - let updatedArticle: [String: Objects.Article] - let updatedFeedArticle: [String: Objects.FeedArticle] - let updatedFeedArticleId: [String: String] - - enum TypeName: String, Codable { - case setShareArticleError = "SetShareArticleError" - case setShareArticleSuccess = "SetShareArticleSuccess" - } - } -} - -extension Unions.SetShareArticleResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SetShareArticleErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "updatedArticle": - if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "updatedFeedArticle": - if let value = try container.decode(Objects.FeedArticle?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "updatedFeedArticleId": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - updatedArticle = map["updatedArticle"] - updatedFeedArticle = map["updatedFeedArticle"] - updatedFeedArticleId = map["updatedFeedArticleId"] - } -} - -extension Fields where TypeLock == Unions.SetShareArticleResult { - func on(setShareArticleError: Selection, setShareArticleSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "SetShareArticleError", selection: setShareArticleError.selection), GraphQLField.fragment(type: "SetShareArticleSuccess", selection: setShareArticleSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .setShareArticleError: - let data = Objects.SetShareArticleError(errorCodes: data.errorCodes) - return try setShareArticleError.decode(data: data) - case .setShareArticleSuccess: - let data = Objects.SetShareArticleSuccess(updatedArticle: data.updatedArticle, updatedFeedArticle: data.updatedFeedArticle, updatedFeedArticleId: data.updatedFeedArticleId) - return try setShareArticleSuccess.decode(data: data) - } - case .mocking: - return setShareArticleError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetShareArticleResult = Selection -} - -extension Unions { - struct SetShareHighlightResult { - let __typename: TypeName - let errorCodes: [String: [Enums.SetShareHighlightErrorCode]] - let highlight: [String: Objects.Highlight] - - enum TypeName: String, Codable { - case setShareHighlightError = "SetShareHighlightError" - case setShareHighlightSuccess = "SetShareHighlightSuccess" - } - } -} - -extension Unions.SetShareHighlightResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SetShareHighlightErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "highlight": - if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - highlight = map["highlight"] - } -} - -extension Fields where TypeLock == Unions.SetShareHighlightResult { - func on(setShareHighlightError: Selection, setShareHighlightSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "SetShareHighlightError", selection: setShareHighlightError.selection), GraphQLField.fragment(type: "SetShareHighlightSuccess", selection: setShareHighlightSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .setShareHighlightError: - let data = Objects.SetShareHighlightError(errorCodes: data.errorCodes) - return try setShareHighlightError.decode(data: data) - case .setShareHighlightSuccess: - let data = Objects.SetShareHighlightSuccess(highlight: data.highlight) - return try setShareHighlightSuccess.decode(data: data) - } - case .mocking: - return setShareHighlightError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetShareHighlightResult = Selection -} - -extension Unions { - struct SetUserPersonalizationResult { - let __typename: TypeName - let errorCodes: [String: [Enums.SetUserPersonalizationErrorCode]] - let updatedUserPersonalization: [String: Objects.UserPersonalization] - - enum TypeName: String, Codable { - case setUserPersonalizationError = "SetUserPersonalizationError" - case setUserPersonalizationSuccess = "SetUserPersonalizationSuccess" - } - } -} - -extension Unions.SetUserPersonalizationResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SetUserPersonalizationErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "updatedUserPersonalization": - if let value = try container.decode(Objects.UserPersonalization?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - updatedUserPersonalization = map["updatedUserPersonalization"] - } -} - -extension Fields where TypeLock == Unions.SetUserPersonalizationResult { - func on(setUserPersonalizationError: Selection, setUserPersonalizationSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "SetUserPersonalizationError", selection: setUserPersonalizationError.selection), GraphQLField.fragment(type: "SetUserPersonalizationSuccess", selection: setUserPersonalizationSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .setUserPersonalizationError: - let data = Objects.SetUserPersonalizationError(errorCodes: data.errorCodes) - return try setUserPersonalizationError.decode(data: data) - case .setUserPersonalizationSuccess: - let data = Objects.SetUserPersonalizationSuccess(updatedUserPersonalization: data.updatedUserPersonalization) - return try setUserPersonalizationSuccess.decode(data: data) - } - case .mocking: - return setUserPersonalizationError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SetUserPersonalizationResult = Selection -} - -extension Unions { - struct SharedArticleResult { - let __typename: TypeName - let article: [String: Objects.Article] - let errorCodes: [String: [Enums.SharedArticleErrorCode]] - - enum TypeName: String, Codable { - case sharedArticleError = "SharedArticleError" - case sharedArticleSuccess = "SharedArticleSuccess" - } - } -} - -extension Unions.SharedArticleResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "article": - if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "errorCodes": - if let value = try container.decode([Enums.SharedArticleErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - article = map["article"] - errorCodes = map["errorCodes"] - } -} - -extension Fields where TypeLock == Unions.SharedArticleResult { - func on(sharedArticleError: Selection, sharedArticleSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "SharedArticleError", selection: sharedArticleError.selection), GraphQLField.fragment(type: "SharedArticleSuccess", selection: sharedArticleSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .sharedArticleError: - let data = Objects.SharedArticleError(errorCodes: data.errorCodes) - return try sharedArticleError.decode(data: data) - case .sharedArticleSuccess: - let data = Objects.SharedArticleSuccess(article: data.article) - return try sharedArticleSuccess.decode(data: data) - } - case .mocking: - return sharedArticleError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SharedArticleResult = Selection -} - -extension Unions { - struct SignupResult { - let __typename: TypeName - let errorCodes: [String: [Enums.SignupErrorCode?]] - let me: [String: Objects.User] - - enum TypeName: String, Codable { - case signupError = "SignupError" - case signupSuccess = "SignupSuccess" - } - } -} - -extension Unions.SignupResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SignupErrorCode?]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "me": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - me = map["me"] - } -} - -extension Fields where TypeLock == Unions.SignupResult { - func on(signupError: Selection, signupSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "SignupError", selection: signupError.selection), GraphQLField.fragment(type: "SignupSuccess", selection: signupSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .signupError: - let data = Objects.SignupError(errorCodes: data.errorCodes) - return try signupError.decode(data: data) - case .signupSuccess: - let data = Objects.SignupSuccess(me: data.me) - return try signupSuccess.decode(data: data) - } - case .mocking: - return signupError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SignupResult = Selection -} - -extension Unions { - struct SubscribeResult { - let __typename: TypeName - let errorCodes: [String: [Enums.SubscribeErrorCode]] - let subscriptions: [String: [Objects.Subscription]] - - enum TypeName: String, Codable { - case subscribeError = "SubscribeError" - case subscribeSuccess = "SubscribeSuccess" - } - } -} - -extension Unions.SubscribeResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SubscribeErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "subscriptions": - if let value = try container.decode([Objects.Subscription]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - subscriptions = map["subscriptions"] - } -} - -extension Fields where TypeLock == Unions.SubscribeResult { - func on(subscribeError: Selection, subscribeSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "SubscribeError", selection: subscribeError.selection), GraphQLField.fragment(type: "SubscribeSuccess", selection: subscribeSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .subscribeError: - let data = Objects.SubscribeError(errorCodes: data.errorCodes) - return try subscribeError.decode(data: data) - case .subscribeSuccess: - let data = Objects.SubscribeSuccess(subscriptions: data.subscriptions) - return try subscribeSuccess.decode(data: data) - } - case .mocking: - return subscribeError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SubscribeResult = Selection -} - -extension Unions { - struct SubscriptionsResult { - let __typename: TypeName - let errorCodes: [String: [Enums.SubscriptionsErrorCode]] - let subscriptions: [String: [Objects.Subscription]] - - enum TypeName: String, Codable { - case subscriptionsError = "SubscriptionsError" - case subscriptionsSuccess = "SubscriptionsSuccess" - } - } -} - -extension Unions.SubscriptionsResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.SubscriptionsErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "subscriptions": - if let value = try container.decode([Objects.Subscription]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - subscriptions = map["subscriptions"] - } -} - -extension Fields where TypeLock == Unions.SubscriptionsResult { - func on(subscriptionsError: Selection, subscriptionsSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "SubscriptionsError", selection: subscriptionsError.selection), GraphQLField.fragment(type: "SubscriptionsSuccess", selection: subscriptionsSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .subscriptionsError: - let data = Objects.SubscriptionsError(errorCodes: data.errorCodes) - return try subscriptionsError.decode(data: data) - case .subscriptionsSuccess: - let data = Objects.SubscriptionsSuccess(subscriptions: data.subscriptions) - return try subscriptionsSuccess.decode(data: data) - } - case .mocking: - return subscriptionsError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias SubscriptionsResult = Selection -} - -extension Unions { - struct UnsubscribeResult { - let __typename: TypeName - let errorCodes: [String: [Enums.UnsubscribeErrorCode]] - let subscription: [String: Objects.Subscription] - - enum TypeName: String, Codable { - case unsubscribeError = "UnsubscribeError" - case unsubscribeSuccess = "UnsubscribeSuccess" - } - } -} - -extension Unions.UnsubscribeResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UnsubscribeErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "subscription": - if let value = try container.decode(Objects.Subscription?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - subscription = map["subscription"] - } -} - -extension Fields where TypeLock == Unions.UnsubscribeResult { - func on(unsubscribeError: Selection, unsubscribeSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "UnsubscribeError", selection: unsubscribeError.selection), GraphQLField.fragment(type: "UnsubscribeSuccess", selection: unsubscribeSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .unsubscribeError: - let data = Objects.UnsubscribeError(errorCodes: data.errorCodes) - return try unsubscribeError.decode(data: data) - case .unsubscribeSuccess: - let data = Objects.UnsubscribeSuccess(subscription: data.subscription) - return try unsubscribeSuccess.decode(data: data) - } - case .mocking: - return unsubscribeError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UnsubscribeResult = Selection -} - -extension Unions { - struct UpdateHighlightReplyResult { - let __typename: TypeName - let errorCodes: [String: [Enums.UpdateHighlightReplyErrorCode]] - let highlightReply: [String: Objects.HighlightReply] - - enum TypeName: String, Codable { - case updateHighlightReplyError = "UpdateHighlightReplyError" - case updateHighlightReplySuccess = "UpdateHighlightReplySuccess" - } - } -} - -extension Unions.UpdateHighlightReplyResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdateHighlightReplyErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "highlightReply": - if let value = try container.decode(Objects.HighlightReply?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - highlightReply = map["highlightReply"] - } -} - -extension Fields where TypeLock == Unions.UpdateHighlightReplyResult { - func on(updateHighlightReplyError: Selection, updateHighlightReplySuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "UpdateHighlightReplyError", selection: updateHighlightReplyError.selection), GraphQLField.fragment(type: "UpdateHighlightReplySuccess", selection: updateHighlightReplySuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .updateHighlightReplyError: - let data = Objects.UpdateHighlightReplyError(errorCodes: data.errorCodes) - return try updateHighlightReplyError.decode(data: data) - case .updateHighlightReplySuccess: - let data = Objects.UpdateHighlightReplySuccess(highlightReply: data.highlightReply) - return try updateHighlightReplySuccess.decode(data: data) - } - case .mocking: - return updateHighlightReplyError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateHighlightReplyResult = Selection -} - -extension Unions { - struct UpdateHighlightResult { - let __typename: TypeName - let errorCodes: [String: [Enums.UpdateHighlightErrorCode]] - let highlight: [String: Objects.Highlight] - - enum TypeName: String, Codable { - case updateHighlightError = "UpdateHighlightError" - case updateHighlightSuccess = "UpdateHighlightSuccess" - } - } -} - -extension Unions.UpdateHighlightResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdateHighlightErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "highlight": - if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - highlight = map["highlight"] - } -} - -extension Fields where TypeLock == Unions.UpdateHighlightResult { - func on(updateHighlightError: Selection, updateHighlightSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "UpdateHighlightError", selection: updateHighlightError.selection), GraphQLField.fragment(type: "UpdateHighlightSuccess", selection: updateHighlightSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .updateHighlightError: - let data = Objects.UpdateHighlightError(errorCodes: data.errorCodes) - return try updateHighlightError.decode(data: data) - case .updateHighlightSuccess: - let data = Objects.UpdateHighlightSuccess(highlight: data.highlight) - return try updateHighlightSuccess.decode(data: data) - } - case .mocking: - return updateHighlightError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateHighlightResult = Selection -} - -extension Unions { - struct UpdateLabelResult { - let __typename: TypeName - let errorCodes: [String: [Enums.UpdateLabelErrorCode]] - let label: [String: Objects.Label] - - enum TypeName: String, Codable { - case updateLabelError = "UpdateLabelError" - case updateLabelSuccess = "UpdateLabelSuccess" - } - } -} - -extension Unions.UpdateLabelResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdateLabelErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "label": - if let value = try container.decode(Objects.Label?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - label = map["label"] - } -} - -extension Fields where TypeLock == Unions.UpdateLabelResult { - func on(updateLabelError: Selection, updateLabelSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "UpdateLabelError", selection: updateLabelError.selection), GraphQLField.fragment(type: "UpdateLabelSuccess", selection: updateLabelSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .updateLabelError: - let data = Objects.UpdateLabelError(errorCodes: data.errorCodes) - return try updateLabelError.decode(data: data) - case .updateLabelSuccess: - let data = Objects.UpdateLabelSuccess(label: data.label) - return try updateLabelSuccess.decode(data: data) - } - case .mocking: - return updateLabelError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateLabelResult = Selection -} - -extension Unions { - struct UpdateLinkShareInfoResult { - let __typename: TypeName - let errorCodes: [String: [Enums.UpdateLinkShareInfoErrorCode]] - let message: [String: String] - - enum TypeName: String, Codable { - case updateLinkShareInfoError = "UpdateLinkShareInfoError" - case updateLinkShareInfoSuccess = "UpdateLinkShareInfoSuccess" - } - } -} - -extension Unions.UpdateLinkShareInfoResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdateLinkShareInfoErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "message": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - message = map["message"] - } -} - -extension Fields where TypeLock == Unions.UpdateLinkShareInfoResult { - func on(updateLinkShareInfoError: Selection, updateLinkShareInfoSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "UpdateLinkShareInfoError", selection: updateLinkShareInfoError.selection), GraphQLField.fragment(type: "UpdateLinkShareInfoSuccess", selection: updateLinkShareInfoSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .updateLinkShareInfoError: - let data = Objects.UpdateLinkShareInfoError(errorCodes: data.errorCodes) - return try updateLinkShareInfoError.decode(data: data) - case .updateLinkShareInfoSuccess: - let data = Objects.UpdateLinkShareInfoSuccess(message: data.message) - return try updateLinkShareInfoSuccess.decode(data: data) - } - case .mocking: - return updateLinkShareInfoError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateLinkShareInfoResult = Selection -} - -extension Unions { - struct UpdatePageResult { - let __typename: TypeName - let errorCodes: [String: [Enums.UpdatePageErrorCode]] - let updatedPage: [String: Objects.Page] - - enum TypeName: String, Codable { - case updatePageError = "UpdatePageError" - case updatePageSuccess = "UpdatePageSuccess" - } - } -} - -extension Unions.UpdatePageResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdatePageErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "updatedPage": - if let value = try container.decode(Objects.Page?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - updatedPage = map["updatedPage"] - } -} - -extension Fields where TypeLock == Unions.UpdatePageResult { - func on(updatePageError: Selection, updatePageSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "UpdatePageError", selection: updatePageError.selection), GraphQLField.fragment(type: "UpdatePageSuccess", selection: updatePageSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .updatePageError: - let data = Objects.UpdatePageError(errorCodes: data.errorCodes) - return try updatePageError.decode(data: data) - case .updatePageSuccess: - let data = Objects.UpdatePageSuccess(updatedPage: data.updatedPage) - return try updatePageSuccess.decode(data: data) - } - case .mocking: - return updatePageError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdatePageResult = Selection -} - -extension Unions { - struct UpdateReminderResult { - let __typename: TypeName - let errorCodes: [String: [Enums.UpdateReminderErrorCode]] - let reminder: [String: Objects.Reminder] - - enum TypeName: String, Codable { - case updateReminderError = "UpdateReminderError" - case updateReminderSuccess = "UpdateReminderSuccess" - } - } -} - -extension Unions.UpdateReminderResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdateReminderErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "reminder": - if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - reminder = map["reminder"] - } -} - -extension Fields where TypeLock == Unions.UpdateReminderResult { - func on(updateReminderError: Selection, updateReminderSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "UpdateReminderError", selection: updateReminderError.selection), GraphQLField.fragment(type: "UpdateReminderSuccess", selection: updateReminderSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .updateReminderError: - let data = Objects.UpdateReminderError(errorCodes: data.errorCodes) - return try updateReminderError.decode(data: data) - case .updateReminderSuccess: - let data = Objects.UpdateReminderSuccess(reminder: data.reminder) - return try updateReminderSuccess.decode(data: data) - } - case .mocking: - return updateReminderError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateReminderResult = Selection -} - -extension Unions { - struct UpdateSharedCommentResult { - let __typename: TypeName - let articleId: [String: String] - let errorCodes: [String: [Enums.UpdateSharedCommentErrorCode]] - let sharedComment: [String: String] - - enum TypeName: String, Codable { - case updateSharedCommentError = "UpdateSharedCommentError" - case updateSharedCommentSuccess = "UpdateSharedCommentSuccess" - } - } -} - -extension Unions.UpdateSharedCommentResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "articleId": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "errorCodes": - if let value = try container.decode([Enums.UpdateSharedCommentErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "sharedComment": - if let value = try container.decode(String?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - articleId = map["articleId"] - errorCodes = map["errorCodes"] - sharedComment = map["sharedComment"] - } -} - -extension Fields where TypeLock == Unions.UpdateSharedCommentResult { - func on(updateSharedCommentError: Selection, updateSharedCommentSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "UpdateSharedCommentError", selection: updateSharedCommentError.selection), GraphQLField.fragment(type: "UpdateSharedCommentSuccess", selection: updateSharedCommentSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .updateSharedCommentError: - let data = Objects.UpdateSharedCommentError(errorCodes: data.errorCodes) - return try updateSharedCommentError.decode(data: data) - case .updateSharedCommentSuccess: - let data = Objects.UpdateSharedCommentSuccess(articleId: data.articleId, sharedComment: data.sharedComment) - return try updateSharedCommentSuccess.decode(data: data) - } - case .mocking: - return updateSharedCommentError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateSharedCommentResult = Selection -} - -extension Unions { - struct UpdateUserProfileResult { - let __typename: TypeName - let errorCodes: [String: [Enums.UpdateUserProfileErrorCode]] - let user: [String: Objects.User] - - enum TypeName: String, Codable { - case updateUserProfileError = "UpdateUserProfileError" - case updateUserProfileSuccess = "UpdateUserProfileSuccess" - } - } -} - -extension Unions.UpdateUserProfileResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdateUserProfileErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "user": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - user = map["user"] - } -} - -extension Fields where TypeLock == Unions.UpdateUserProfileResult { - func on(updateUserProfileError: Selection, updateUserProfileSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "UpdateUserProfileError", selection: updateUserProfileError.selection), GraphQLField.fragment(type: "UpdateUserProfileSuccess", selection: updateUserProfileSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .updateUserProfileError: - let data = Objects.UpdateUserProfileError(errorCodes: data.errorCodes) - return try updateUserProfileError.decode(data: data) - case .updateUserProfileSuccess: - let data = Objects.UpdateUserProfileSuccess(user: data.user) - return try updateUserProfileSuccess.decode(data: data) - } - case .mocking: - return updateUserProfileError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateUserProfileResult = Selection -} - -extension Unions { - struct UpdateUserResult { - let __typename: TypeName - let errorCodes: [String: [Enums.UpdateUserErrorCode]] - let user: [String: Objects.User] - - enum TypeName: String, Codable { - case updateUserError = "UpdateUserError" - case updateUserSuccess = "UpdateUserSuccess" - } - } -} - -extension Unions.UpdateUserResult: Decodable { - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: DynamicCodingKeys.self) - - var map = HashMap() - for codingKey in container.allKeys { - if codingKey.isTypenameKey { continue } - - let alias = codingKey.stringValue - let field = GraphQLField.getFieldNameFromAlias(alias) - - switch field { - case "errorCodes": - if let value = try container.decode([Enums.UpdateUserErrorCode]?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - case "user": - if let value = try container.decode(Objects.User?.self, forKey: codingKey) { - map.set(key: field, hash: alias, value: value as Any) - } - default: - throw DecodingError.dataCorrupted( - DecodingError.Context( - codingPath: decoder.codingPath, - debugDescription: "Unknown key \(field)." - ) - ) - } - } - - __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) - - errorCodes = map["errorCodes"] - user = map["user"] - } -} - -extension Fields where TypeLock == Unions.UpdateUserResult { - func on(updateUserError: Selection, updateUserSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "UpdateUserError", selection: updateUserError.selection), GraphQLField.fragment(type: "UpdateUserSuccess", selection: updateUserSuccess.selection)]) - - switch response { - case let .decoding(data): - switch data.__typename { - case .updateUserError: - let data = Objects.UpdateUserError(errorCodes: data.errorCodes) - return try updateUserError.decode(data: data) - case .updateUserSuccess: - let data = Objects.UpdateUserSuccess(user: data.user) - return try updateUserSuccess.decode(data: data) - } - case .mocking: - return updateUserError.mock() - } - } -} - -extension Selection where TypeLock == Never, Type == Never { - typealias UpdateUserResult = Selection -} - extension Unions { struct UploadFileRequestResult { let __typename: TypeName @@ -19530,8 +16176,8 @@ extension Unions { let uploadSignedUrl: [String: String] enum TypeName: String, Codable { - case uploadFileRequestError = "UploadFileRequestError" case uploadFileRequestSuccess = "UploadFileRequestSuccess" + case uploadFileRequestError = "UploadFileRequestError" } } } @@ -19584,21 +16230,21 @@ extension Unions.UploadFileRequestResult: Decodable { } extension Fields where TypeLock == Unions.UploadFileRequestResult { - func on(uploadFileRequestError: Selection, uploadFileRequestSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "UploadFileRequestError", selection: uploadFileRequestError.selection), GraphQLField.fragment(type: "UploadFileRequestSuccess", selection: uploadFileRequestSuccess.selection)]) + func on(uploadFileRequestSuccess: Selection, uploadFileRequestError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "UploadFileRequestSuccess", selection: uploadFileRequestSuccess.selection), GraphQLField.fragment(type: "UploadFileRequestError", selection: uploadFileRequestError.selection)]) switch response { case let .decoding(data): switch data.__typename { - case .uploadFileRequestError: - let data = Objects.UploadFileRequestError(errorCodes: data.errorCodes) - return try uploadFileRequestError.decode(data: data) case .uploadFileRequestSuccess: let data = Objects.UploadFileRequestSuccess(id: data.id, uploadFileId: data.uploadFileId, uploadSignedUrl: data.uploadSignedUrl) return try uploadFileRequestSuccess.decode(data: data) + case .uploadFileRequestError: + let data = Objects.UploadFileRequestError(errorCodes: data.errorCodes) + return try uploadFileRequestError.decode(data: data) } case .mocking: - return uploadFileRequestError.mock() + return uploadFileRequestSuccess.mock() } } } @@ -19608,19 +16254,21 @@ extension Selection where TypeLock == Never, Type == Never { } extension Unions { - struct UserResult { + struct CreateArticleResult { let __typename: TypeName - let errorCodes: [String: [Enums.UserErrorCode]] + let created: [String: Bool] + let createdArticle: [String: Objects.Article] + let errorCodes: [String: [Enums.CreateArticleErrorCode]] let user: [String: Objects.User] enum TypeName: String, Codable { - case userError = "UserError" - case userSuccess = "UserSuccess" + case createArticleSuccess = "CreateArticleSuccess" + case createArticleError = "CreateArticleError" } } } -extension Unions.UserResult: Decodable { +extension Unions.CreateArticleResult: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -19632,8 +16280,16 @@ extension Unions.UserResult: Decodable { let field = GraphQLField.getFieldNameFromAlias(alias) switch field { + case "created": + if let value = try container.decode(Bool?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "createdArticle": + if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } case "errorCodes": - if let value = try container.decode([Enums.UserErrorCode]?.self, forKey: codingKey) { + if let value = try container.decode([Enums.CreateArticleErrorCode]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } case "user": @@ -19652,49 +16308,137 @@ extension Unions.UserResult: Decodable { __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + created = map["created"] + createdArticle = map["createdArticle"] errorCodes = map["errorCodes"] user = map["user"] } } -extension Fields where TypeLock == Unions.UserResult { - func on(userError: Selection, userSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "UserError", selection: userError.selection), GraphQLField.fragment(type: "UserSuccess", selection: userSuccess.selection)]) +extension Fields where TypeLock == Unions.CreateArticleResult { + func on(createArticleSuccess: Selection, createArticleError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "CreateArticleSuccess", selection: createArticleSuccess.selection), GraphQLField.fragment(type: "CreateArticleError", selection: createArticleError.selection)]) switch response { case let .decoding(data): switch data.__typename { - case .userError: - let data = Objects.UserError(errorCodes: data.errorCodes) - return try userError.decode(data: data) - case .userSuccess: - let data = Objects.UserSuccess(user: data.user) - return try userSuccess.decode(data: data) + case .createArticleSuccess: + let data = Objects.CreateArticleSuccess(created: data.created, createdArticle: data.createdArticle, user: data.user) + return try createArticleSuccess.decode(data: data) + case .createArticleError: + let data = Objects.CreateArticleError(errorCodes: data.errorCodes) + return try createArticleError.decode(data: data) } case .mocking: - return userError.mock() + return createArticleSuccess.mock() } } } extension Selection where TypeLock == Never, Type == Never { - typealias UserResult = Selection + typealias CreateArticleResult = Selection } extension Unions { - struct UsersResult { + struct SaveResult { let __typename: TypeName - let errorCodes: [String: [Enums.UsersErrorCode]] - let users: [String: [Objects.User]] + let clientRequestId: [String: String] + let errorCodes: [String: [Enums.SaveErrorCode]] + let message: [String: String] + let url: [String: String] enum TypeName: String, Codable { - case usersError = "UsersError" - case usersSuccess = "UsersSuccess" + case saveSuccess = "SaveSuccess" + case saveError = "SaveError" } } } -extension Unions.UsersResult: Decodable { +extension Unions.SaveResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "clientRequestId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "errorCodes": + if let value = try container.decode([Enums.SaveErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "message": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "url": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + clientRequestId = map["clientRequestId"] + errorCodes = map["errorCodes"] + message = map["message"] + url = map["url"] + } +} + +extension Fields where TypeLock == Unions.SaveResult { + func on(saveSuccess: Selection, saveError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "SaveSuccess", selection: saveSuccess.selection), GraphQLField.fragment(type: "SaveError", selection: saveError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .saveSuccess: + let data = Objects.SaveSuccess(clientRequestId: data.clientRequestId, url: data.url) + return try saveSuccess.decode(data: data) + case .saveError: + let data = Objects.SaveError(errorCodes: data.errorCodes, message: data.message) + return try saveError.decode(data: data) + } + case .mocking: + return saveSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SaveResult = Selection +} + +extension Unions { + struct UpdatePageResult { + let __typename: TypeName + let errorCodes: [String: [Enums.UpdatePageErrorCode]] + let updatedPage: [String: Objects.Page] + + enum TypeName: String, Codable { + case updatePageSuccess = "UpdatePageSuccess" + case updatePageError = "UpdatePageError" + } + } +} + +extension Unions.UpdatePageResult: Decodable { init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: DynamicCodingKeys.self) @@ -19707,10 +16451,1224 @@ extension Unions.UsersResult: Decodable { switch field { case "errorCodes": - if let value = try container.decode([Enums.UsersErrorCode]?.self, forKey: codingKey) { + if let value = try container.decode([Enums.UpdatePageErrorCode]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } - case "users": + case "updatedPage": + if let value = try container.decode(Objects.Page?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + updatedPage = map["updatedPage"] + } +} + +extension Fields where TypeLock == Unions.UpdatePageResult { + func on(updatePageSuccess: Selection, updatePageError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "UpdatePageSuccess", selection: updatePageSuccess.selection), GraphQLField.fragment(type: "UpdatePageError", selection: updatePageError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .updatePageSuccess: + let data = Objects.UpdatePageSuccess(updatedPage: data.updatedPage) + return try updatePageSuccess.decode(data: data) + case .updatePageError: + let data = Objects.UpdatePageError(errorCodes: data.errorCodes) + return try updatePageError.decode(data: data) + } + case .mocking: + return updatePageSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdatePageResult = Selection +} + +extension Unions { + struct SetFollowResult { + let __typename: TypeName + let errorCodes: [String: [Enums.SetFollowErrorCode]] + let updatedUser: [String: Objects.User] + + enum TypeName: String, Codable { + case setFollowSuccess = "SetFollowSuccess" + case setFollowError = "SetFollowError" + } + } +} + +extension Unions.SetFollowResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SetFollowErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "updatedUser": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + updatedUser = map["updatedUser"] + } +} + +extension Fields where TypeLock == Unions.SetFollowResult { + func on(setFollowSuccess: Selection, setFollowError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "SetFollowSuccess", selection: setFollowSuccess.selection), GraphQLField.fragment(type: "SetFollowError", selection: setFollowError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .setFollowSuccess: + let data = Objects.SetFollowSuccess(updatedUser: data.updatedUser) + return try setFollowSuccess.decode(data: data) + case .setFollowError: + let data = Objects.SetFollowError(errorCodes: data.errorCodes) + return try setFollowError.decode(data: data) + } + case .mocking: + return setFollowSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetFollowResult = Selection +} + +extension Unions { + struct SaveArticleReadingProgressResult { + let __typename: TypeName + let errorCodes: [String: [Enums.SaveArticleReadingProgressErrorCode]] + let updatedArticle: [String: Objects.Article] + + enum TypeName: String, Codable { + case saveArticleReadingProgressSuccess = "SaveArticleReadingProgressSuccess" + case saveArticleReadingProgressError = "SaveArticleReadingProgressError" + } + } +} + +extension Unions.SaveArticleReadingProgressResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SaveArticleReadingProgressErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "updatedArticle": + if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + updatedArticle = map["updatedArticle"] + } +} + +extension Fields where TypeLock == Unions.SaveArticleReadingProgressResult { + func on(saveArticleReadingProgressSuccess: Selection, saveArticleReadingProgressError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "SaveArticleReadingProgressSuccess", selection: saveArticleReadingProgressSuccess.selection), GraphQLField.fragment(type: "SaveArticleReadingProgressError", selection: saveArticleReadingProgressError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .saveArticleReadingProgressSuccess: + let data = Objects.SaveArticleReadingProgressSuccess(updatedArticle: data.updatedArticle) + return try saveArticleReadingProgressSuccess.decode(data: data) + case .saveArticleReadingProgressError: + let data = Objects.SaveArticleReadingProgressError(errorCodes: data.errorCodes) + return try saveArticleReadingProgressError.decode(data: data) + } + case .mocking: + return saveArticleReadingProgressSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SaveArticleReadingProgressResult = Selection +} + +extension Unions { + struct SetBookmarkArticleResult { + let __typename: TypeName + let bookmarkedArticle: [String: Objects.Article] + let errorCodes: [String: [Enums.SetBookmarkArticleErrorCode]] + + enum TypeName: String, Codable { + case setBookmarkArticleSuccess = "SetBookmarkArticleSuccess" + case setBookmarkArticleError = "SetBookmarkArticleError" + } + } +} + +extension Unions.SetBookmarkArticleResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "bookmarkedArticle": + if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "errorCodes": + if let value = try container.decode([Enums.SetBookmarkArticleErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + bookmarkedArticle = map["bookmarkedArticle"] + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Unions.SetBookmarkArticleResult { + func on(setBookmarkArticleSuccess: Selection, setBookmarkArticleError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "SetBookmarkArticleSuccess", selection: setBookmarkArticleSuccess.selection), GraphQLField.fragment(type: "SetBookmarkArticleError", selection: setBookmarkArticleError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .setBookmarkArticleSuccess: + let data = Objects.SetBookmarkArticleSuccess(bookmarkedArticle: data.bookmarkedArticle) + return try setBookmarkArticleSuccess.decode(data: data) + case .setBookmarkArticleError: + let data = Objects.SetBookmarkArticleError(errorCodes: data.errorCodes) + return try setBookmarkArticleError.decode(data: data) + } + case .mocking: + return setBookmarkArticleSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetBookmarkArticleResult = Selection +} + +extension Unions { + struct CreateHighlightResult { + let __typename: TypeName + let errorCodes: [String: [Enums.CreateHighlightErrorCode]] + let highlight: [String: Objects.Highlight] + + enum TypeName: String, Codable { + case createHighlightSuccess = "CreateHighlightSuccess" + case createHighlightError = "CreateHighlightError" + } + } +} + +extension Unions.CreateHighlightResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.CreateHighlightErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "highlight": + if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + highlight = map["highlight"] + } +} + +extension Fields where TypeLock == Unions.CreateHighlightResult { + func on(createHighlightSuccess: Selection, createHighlightError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "CreateHighlightSuccess", selection: createHighlightSuccess.selection), GraphQLField.fragment(type: "CreateHighlightError", selection: createHighlightError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .createHighlightSuccess: + let data = Objects.CreateHighlightSuccess(highlight: data.highlight) + return try createHighlightSuccess.decode(data: data) + case .createHighlightError: + let data = Objects.CreateHighlightError(errorCodes: data.errorCodes) + return try createHighlightError.decode(data: data) + } + case .mocking: + return createHighlightSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateHighlightResult = Selection +} + +extension Unions { + struct MergeHighlightResult { + let __typename: TypeName + let errorCodes: [String: [Enums.MergeHighlightErrorCode]] + let highlight: [String: Objects.Highlight] + let overlapHighlightIdList: [String: [String]] + + enum TypeName: String, Codable { + case mergeHighlightSuccess = "MergeHighlightSuccess" + case mergeHighlightError = "MergeHighlightError" + } + } +} + +extension Unions.MergeHighlightResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.MergeHighlightErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "highlight": + if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "overlapHighlightIdList": + if let value = try container.decode([String]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + highlight = map["highlight"] + overlapHighlightIdList = map["overlapHighlightIdList"] + } +} + +extension Fields where TypeLock == Unions.MergeHighlightResult { + func on(mergeHighlightSuccess: Selection, mergeHighlightError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "MergeHighlightSuccess", selection: mergeHighlightSuccess.selection), GraphQLField.fragment(type: "MergeHighlightError", selection: mergeHighlightError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .mergeHighlightSuccess: + let data = Objects.MergeHighlightSuccess(highlight: data.highlight, overlapHighlightIdList: data.overlapHighlightIdList) + return try mergeHighlightSuccess.decode(data: data) + case .mergeHighlightError: + let data = Objects.MergeHighlightError(errorCodes: data.errorCodes) + return try mergeHighlightError.decode(data: data) + } + case .mocking: + return mergeHighlightSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias MergeHighlightResult = Selection +} + +extension Unions { + struct UpdateHighlightResult { + let __typename: TypeName + let errorCodes: [String: [Enums.UpdateHighlightErrorCode]] + let highlight: [String: Objects.Highlight] + + enum TypeName: String, Codable { + case updateHighlightSuccess = "UpdateHighlightSuccess" + case updateHighlightError = "UpdateHighlightError" + } + } +} + +extension Unions.UpdateHighlightResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdateHighlightErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "highlight": + if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + highlight = map["highlight"] + } +} + +extension Fields where TypeLock == Unions.UpdateHighlightResult { + func on(updateHighlightSuccess: Selection, updateHighlightError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "UpdateHighlightSuccess", selection: updateHighlightSuccess.selection), GraphQLField.fragment(type: "UpdateHighlightError", selection: updateHighlightError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .updateHighlightSuccess: + let data = Objects.UpdateHighlightSuccess(highlight: data.highlight) + return try updateHighlightSuccess.decode(data: data) + case .updateHighlightError: + let data = Objects.UpdateHighlightError(errorCodes: data.errorCodes) + return try updateHighlightError.decode(data: data) + } + case .mocking: + return updateHighlightSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateHighlightResult = Selection +} + +extension Unions { + struct DeleteHighlightResult { + let __typename: TypeName + let errorCodes: [String: [Enums.DeleteHighlightErrorCode]] + let highlight: [String: Objects.Highlight] + + enum TypeName: String, Codable { + case deleteHighlightSuccess = "DeleteHighlightSuccess" + case deleteHighlightError = "DeleteHighlightError" + } + } +} + +extension Unions.DeleteHighlightResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.DeleteHighlightErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "highlight": + if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + highlight = map["highlight"] + } +} + +extension Fields where TypeLock == Unions.DeleteHighlightResult { + func on(deleteHighlightSuccess: Selection, deleteHighlightError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "DeleteHighlightSuccess", selection: deleteHighlightSuccess.selection), GraphQLField.fragment(type: "DeleteHighlightError", selection: deleteHighlightError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .deleteHighlightSuccess: + let data = Objects.DeleteHighlightSuccess(highlight: data.highlight) + return try deleteHighlightSuccess.decode(data: data) + case .deleteHighlightError: + let data = Objects.DeleteHighlightError(errorCodes: data.errorCodes) + return try deleteHighlightError.decode(data: data) + } + case .mocking: + return deleteHighlightSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteHighlightResult = Selection +} + +extension Unions { + struct CreateHighlightReplyResult { + let __typename: TypeName + let errorCodes: [String: [Enums.CreateHighlightReplyErrorCode]] + let highlightReply: [String: Objects.HighlightReply] + + enum TypeName: String, Codable { + case createHighlightReplySuccess = "CreateHighlightReplySuccess" + case createHighlightReplyError = "CreateHighlightReplyError" + } + } +} + +extension Unions.CreateHighlightReplyResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.CreateHighlightReplyErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "highlightReply": + if let value = try container.decode(Objects.HighlightReply?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + highlightReply = map["highlightReply"] + } +} + +extension Fields where TypeLock == Unions.CreateHighlightReplyResult { + func on(createHighlightReplySuccess: Selection, createHighlightReplyError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "CreateHighlightReplySuccess", selection: createHighlightReplySuccess.selection), GraphQLField.fragment(type: "CreateHighlightReplyError", selection: createHighlightReplyError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .createHighlightReplySuccess: + let data = Objects.CreateHighlightReplySuccess(highlightReply: data.highlightReply) + return try createHighlightReplySuccess.decode(data: data) + case .createHighlightReplyError: + let data = Objects.CreateHighlightReplyError(errorCodes: data.errorCodes) + return try createHighlightReplyError.decode(data: data) + } + case .mocking: + return createHighlightReplySuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateHighlightReplyResult = Selection +} + +extension Unions { + struct UpdateHighlightReplyResult { + let __typename: TypeName + let errorCodes: [String: [Enums.UpdateHighlightReplyErrorCode]] + let highlightReply: [String: Objects.HighlightReply] + + enum TypeName: String, Codable { + case updateHighlightReplySuccess = "UpdateHighlightReplySuccess" + case updateHighlightReplyError = "UpdateHighlightReplyError" + } + } +} + +extension Unions.UpdateHighlightReplyResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdateHighlightReplyErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "highlightReply": + if let value = try container.decode(Objects.HighlightReply?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + highlightReply = map["highlightReply"] + } +} + +extension Fields where TypeLock == Unions.UpdateHighlightReplyResult { + func on(updateHighlightReplySuccess: Selection, updateHighlightReplyError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "UpdateHighlightReplySuccess", selection: updateHighlightReplySuccess.selection), GraphQLField.fragment(type: "UpdateHighlightReplyError", selection: updateHighlightReplyError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .updateHighlightReplySuccess: + let data = Objects.UpdateHighlightReplySuccess(highlightReply: data.highlightReply) + return try updateHighlightReplySuccess.decode(data: data) + case .updateHighlightReplyError: + let data = Objects.UpdateHighlightReplyError(errorCodes: data.errorCodes) + return try updateHighlightReplyError.decode(data: data) + } + case .mocking: + return updateHighlightReplySuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateHighlightReplyResult = Selection +} + +extension Unions { + struct DeleteHighlightReplyResult { + let __typename: TypeName + let errorCodes: [String: [Enums.DeleteHighlightReplyErrorCode]] + let highlightReply: [String: Objects.HighlightReply] + + enum TypeName: String, Codable { + case deleteHighlightReplySuccess = "DeleteHighlightReplySuccess" + case deleteHighlightReplyError = "DeleteHighlightReplyError" + } + } +} + +extension Unions.DeleteHighlightReplyResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.DeleteHighlightReplyErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "highlightReply": + if let value = try container.decode(Objects.HighlightReply?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + highlightReply = map["highlightReply"] + } +} + +extension Fields where TypeLock == Unions.DeleteHighlightReplyResult { + func on(deleteHighlightReplySuccess: Selection, deleteHighlightReplyError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "DeleteHighlightReplySuccess", selection: deleteHighlightReplySuccess.selection), GraphQLField.fragment(type: "DeleteHighlightReplyError", selection: deleteHighlightReplyError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .deleteHighlightReplySuccess: + let data = Objects.DeleteHighlightReplySuccess(highlightReply: data.highlightReply) + return try deleteHighlightReplySuccess.decode(data: data) + case .deleteHighlightReplyError: + let data = Objects.DeleteHighlightReplyError(errorCodes: data.errorCodes) + return try deleteHighlightReplyError.decode(data: data) + } + case .mocking: + return deleteHighlightReplySuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteHighlightReplyResult = Selection +} + +extension Unions { + struct CreateReactionResult { + let __typename: TypeName + let errorCodes: [String: [Enums.CreateReactionErrorCode]] + let reaction: [String: Objects.Reaction] + + enum TypeName: String, Codable { + case createReactionSuccess = "CreateReactionSuccess" + case createReactionError = "CreateReactionError" + } + } +} + +extension Unions.CreateReactionResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.CreateReactionErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "reaction": + if let value = try container.decode(Objects.Reaction?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + reaction = map["reaction"] + } +} + +extension Fields where TypeLock == Unions.CreateReactionResult { + func on(createReactionSuccess: Selection, createReactionError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "CreateReactionSuccess", selection: createReactionSuccess.selection), GraphQLField.fragment(type: "CreateReactionError", selection: createReactionError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .createReactionSuccess: + let data = Objects.CreateReactionSuccess(reaction: data.reaction) + return try createReactionSuccess.decode(data: data) + case .createReactionError: + let data = Objects.CreateReactionError(errorCodes: data.errorCodes) + return try createReactionError.decode(data: data) + } + case .mocking: + return createReactionSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateReactionResult = Selection +} + +extension Unions { + struct DeleteReactionResult { + let __typename: TypeName + let errorCodes: [String: [Enums.DeleteReactionErrorCode]] + let reaction: [String: Objects.Reaction] + + enum TypeName: String, Codable { + case deleteReactionSuccess = "DeleteReactionSuccess" + case deleteReactionError = "DeleteReactionError" + } + } +} + +extension Unions.DeleteReactionResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.DeleteReactionErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "reaction": + if let value = try container.decode(Objects.Reaction?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + reaction = map["reaction"] + } +} + +extension Fields where TypeLock == Unions.DeleteReactionResult { + func on(deleteReactionSuccess: Selection, deleteReactionError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "DeleteReactionSuccess", selection: deleteReactionSuccess.selection), GraphQLField.fragment(type: "DeleteReactionError", selection: deleteReactionError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .deleteReactionSuccess: + let data = Objects.DeleteReactionSuccess(reaction: data.reaction) + return try deleteReactionSuccess.decode(data: data) + case .deleteReactionError: + let data = Objects.DeleteReactionError(errorCodes: data.errorCodes) + return try deleteReactionError.decode(data: data) + } + case .mocking: + return deleteReactionSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteReactionResult = Selection +} + +extension Unions { + struct FeedArticlesResult { + let __typename: TypeName + let edges: [String: [Objects.FeedArticleEdge]] + let errorCodes: [String: [Enums.FeedArticlesErrorCode]] + let pageInfo: [String: Objects.PageInfo] + + enum TypeName: String, Codable { + case feedArticlesSuccess = "FeedArticlesSuccess" + case feedArticlesError = "FeedArticlesError" + } + } +} + +extension Unions.FeedArticlesResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "edges": + if let value = try container.decode([Objects.FeedArticleEdge]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "errorCodes": + if let value = try container.decode([Enums.FeedArticlesErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "pageInfo": + if let value = try container.decode(Objects.PageInfo?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + edges = map["edges"] + errorCodes = map["errorCodes"] + pageInfo = map["pageInfo"] + } +} + +extension Fields where TypeLock == Unions.FeedArticlesResult { + func on(feedArticlesSuccess: Selection, feedArticlesError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "FeedArticlesSuccess", selection: feedArticlesSuccess.selection), GraphQLField.fragment(type: "FeedArticlesError", selection: feedArticlesError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .feedArticlesSuccess: + let data = Objects.FeedArticlesSuccess(edges: data.edges, pageInfo: data.pageInfo) + return try feedArticlesSuccess.decode(data: data) + case .feedArticlesError: + let data = Objects.FeedArticlesError(errorCodes: data.errorCodes) + return try feedArticlesError.decode(data: data) + } + case .mocking: + return feedArticlesSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias FeedArticlesResult = Selection +} + +extension Unions { + struct SetShareArticleResult { + let __typename: TypeName + let errorCodes: [String: [Enums.SetShareArticleErrorCode]] + let updatedArticle: [String: Objects.Article] + let updatedFeedArticle: [String: Objects.FeedArticle] + let updatedFeedArticleId: [String: String] + + enum TypeName: String, Codable { + case setShareArticleSuccess = "SetShareArticleSuccess" + case setShareArticleError = "SetShareArticleError" + } + } +} + +extension Unions.SetShareArticleResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SetShareArticleErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "updatedArticle": + if let value = try container.decode(Objects.Article?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "updatedFeedArticle": + if let value = try container.decode(Objects.FeedArticle?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "updatedFeedArticleId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + updatedArticle = map["updatedArticle"] + updatedFeedArticle = map["updatedFeedArticle"] + updatedFeedArticleId = map["updatedFeedArticleId"] + } +} + +extension Fields where TypeLock == Unions.SetShareArticleResult { + func on(setShareArticleSuccess: Selection, setShareArticleError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "SetShareArticleSuccess", selection: setShareArticleSuccess.selection), GraphQLField.fragment(type: "SetShareArticleError", selection: setShareArticleError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .setShareArticleSuccess: + let data = Objects.SetShareArticleSuccess(updatedArticle: data.updatedArticle, updatedFeedArticle: data.updatedFeedArticle, updatedFeedArticleId: data.updatedFeedArticleId) + return try setShareArticleSuccess.decode(data: data) + case .setShareArticleError: + let data = Objects.SetShareArticleError(errorCodes: data.errorCodes) + return try setShareArticleError.decode(data: data) + } + case .mocking: + return setShareArticleSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetShareArticleResult = Selection +} + +extension Unions { + struct UpdateSharedCommentResult { + let __typename: TypeName + let articleId: [String: String] + let errorCodes: [String: [Enums.UpdateSharedCommentErrorCode]] + let sharedComment: [String: String] + + enum TypeName: String, Codable { + case updateSharedCommentSuccess = "UpdateSharedCommentSuccess" + case updateSharedCommentError = "UpdateSharedCommentError" + } + } +} + +extension Unions.UpdateSharedCommentResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "articleId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "errorCodes": + if let value = try container.decode([Enums.UpdateSharedCommentErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "sharedComment": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + articleId = map["articleId"] + errorCodes = map["errorCodes"] + sharedComment = map["sharedComment"] + } +} + +extension Fields where TypeLock == Unions.UpdateSharedCommentResult { + func on(updateSharedCommentSuccess: Selection, updateSharedCommentError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "UpdateSharedCommentSuccess", selection: updateSharedCommentSuccess.selection), GraphQLField.fragment(type: "UpdateSharedCommentError", selection: updateSharedCommentError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .updateSharedCommentSuccess: + let data = Objects.UpdateSharedCommentSuccess(articleId: data.articleId, sharedComment: data.sharedComment) + return try updateSharedCommentSuccess.decode(data: data) + case .updateSharedCommentError: + let data = Objects.UpdateSharedCommentError(errorCodes: data.errorCodes) + return try updateSharedCommentError.decode(data: data) + } + case .mocking: + return updateSharedCommentSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateSharedCommentResult = Selection +} + +extension Unions { + struct GetFollowersResult { + let __typename: TypeName + let errorCodes: [String: [Enums.GetFollowersErrorCode]] + let followers: [String: [Objects.User]] + + enum TypeName: String, Codable { + case getFollowersSuccess = "GetFollowersSuccess" + case getFollowersError = "GetFollowersError" + } + } +} + +extension Unions.GetFollowersResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.GetFollowersErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "followers": if let value = try container.decode([Objects.User]?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } @@ -19727,85 +17685,2292 @@ extension Unions.UsersResult: Decodable { __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) errorCodes = map["errorCodes"] - users = map["users"] + followers = map["followers"] } } -extension Fields where TypeLock == Unions.UsersResult { - func on(usersError: Selection, usersSuccess: Selection) throws -> Type { - select([GraphQLField.fragment(type: "UsersError", selection: usersError.selection), GraphQLField.fragment(type: "UsersSuccess", selection: usersSuccess.selection)]) +extension Fields where TypeLock == Unions.GetFollowersResult { + func on(getFollowersSuccess: Selection, getFollowersError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "GetFollowersSuccess", selection: getFollowersSuccess.selection), GraphQLField.fragment(type: "GetFollowersError", selection: getFollowersError.selection)]) switch response { case let .decoding(data): switch data.__typename { - case .usersError: - let data = Objects.UsersError(errorCodes: data.errorCodes) - return try usersError.decode(data: data) - case .usersSuccess: - let data = Objects.UsersSuccess(users: data.users) - return try usersSuccess.decode(data: data) + case .getFollowersSuccess: + let data = Objects.GetFollowersSuccess(followers: data.followers) + return try getFollowersSuccess.decode(data: data) + case .getFollowersError: + let data = Objects.GetFollowersError(errorCodes: data.errorCodes) + return try getFollowersError.decode(data: data) } case .mocking: - return usersError.mock() + return getFollowersSuccess.mock() } } } extension Selection where TypeLock == Never, Type == Never { - typealias UsersResult = Selection + typealias GetFollowersResult = Selection +} + +extension Unions { + struct GetFollowingResult { + let __typename: TypeName + let errorCodes: [String: [Enums.GetFollowingErrorCode]] + let following: [String: [Objects.User]] + + enum TypeName: String, Codable { + case getFollowingSuccess = "GetFollowingSuccess" + case getFollowingError = "GetFollowingError" + } + } +} + +extension Unions.GetFollowingResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.GetFollowingErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "following": + if let value = try container.decode([Objects.User]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + following = map["following"] + } +} + +extension Fields where TypeLock == Unions.GetFollowingResult { + func on(getFollowingSuccess: Selection, getFollowingError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "GetFollowingSuccess", selection: getFollowingSuccess.selection), GraphQLField.fragment(type: "GetFollowingError", selection: getFollowingError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .getFollowingSuccess: + let data = Objects.GetFollowingSuccess(following: data.following) + return try getFollowingSuccess.decode(data: data) + case .getFollowingError: + let data = Objects.GetFollowingError(errorCodes: data.errorCodes) + return try getFollowingError.decode(data: data) + } + case .mocking: + return getFollowingSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias GetFollowingResult = Selection +} + +extension Unions { + struct GetUserPersonalizationResult { + let __typename: TypeName + let errorCodes: [String: [Enums.GetUserPersonalizationErrorCode]] + let userPersonalization: [String: Objects.UserPersonalization] + + enum TypeName: String, Codable { + case getUserPersonalizationSuccess = "GetUserPersonalizationSuccess" + case getUserPersonalizationError = "GetUserPersonalizationError" + } + } +} + +extension Unions.GetUserPersonalizationResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.GetUserPersonalizationErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "userPersonalization": + if let value = try container.decode(Objects.UserPersonalization?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + userPersonalization = map["userPersonalization"] + } +} + +extension Fields where TypeLock == Unions.GetUserPersonalizationResult { + func on(getUserPersonalizationSuccess: Selection, getUserPersonalizationError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "GetUserPersonalizationSuccess", selection: getUserPersonalizationSuccess.selection), GraphQLField.fragment(type: "GetUserPersonalizationError", selection: getUserPersonalizationError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .getUserPersonalizationSuccess: + let data = Objects.GetUserPersonalizationSuccess(userPersonalization: data.userPersonalization) + return try getUserPersonalizationSuccess.decode(data: data) + case .getUserPersonalizationError: + let data = Objects.GetUserPersonalizationError(errorCodes: data.errorCodes) + return try getUserPersonalizationError.decode(data: data) + } + case .mocking: + return getUserPersonalizationSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias GetUserPersonalizationResult = Selection +} + +extension Unions { + struct SetUserPersonalizationResult { + let __typename: TypeName + let errorCodes: [String: [Enums.SetUserPersonalizationErrorCode]] + let updatedUserPersonalization: [String: Objects.UserPersonalization] + + enum TypeName: String, Codable { + case setUserPersonalizationSuccess = "SetUserPersonalizationSuccess" + case setUserPersonalizationError = "SetUserPersonalizationError" + } + } +} + +extension Unions.SetUserPersonalizationResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SetUserPersonalizationErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "updatedUserPersonalization": + if let value = try container.decode(Objects.UserPersonalization?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + updatedUserPersonalization = map["updatedUserPersonalization"] + } +} + +extension Fields where TypeLock == Unions.SetUserPersonalizationResult { + func on(setUserPersonalizationSuccess: Selection, setUserPersonalizationError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "SetUserPersonalizationSuccess", selection: setUserPersonalizationSuccess.selection), GraphQLField.fragment(type: "SetUserPersonalizationError", selection: setUserPersonalizationError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .setUserPersonalizationSuccess: + let data = Objects.SetUserPersonalizationSuccess(updatedUserPersonalization: data.updatedUserPersonalization) + return try setUserPersonalizationSuccess.decode(data: data) + case .setUserPersonalizationError: + let data = Objects.SetUserPersonalizationError(errorCodes: data.errorCodes) + return try setUserPersonalizationError.decode(data: data) + } + case .mocking: + return setUserPersonalizationSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetUserPersonalizationResult = Selection +} + +extension Unions { + struct ArticleSavingRequestResult { + let __typename: TypeName + let articleSavingRequest: [String: Objects.ArticleSavingRequest] + let errorCodes: [String: [Enums.ArticleSavingRequestErrorCode]] + + enum TypeName: String, Codable { + case articleSavingRequestSuccess = "ArticleSavingRequestSuccess" + case articleSavingRequestError = "ArticleSavingRequestError" + } + } +} + +extension Unions.ArticleSavingRequestResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "articleSavingRequest": + if let value = try container.decode(Objects.ArticleSavingRequest?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "errorCodes": + if let value = try container.decode([Enums.ArticleSavingRequestErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + articleSavingRequest = map["articleSavingRequest"] + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Unions.ArticleSavingRequestResult { + func on(articleSavingRequestSuccess: Selection, articleSavingRequestError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "ArticleSavingRequestSuccess", selection: articleSavingRequestSuccess.selection), GraphQLField.fragment(type: "ArticleSavingRequestError", selection: articleSavingRequestError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .articleSavingRequestSuccess: + let data = Objects.ArticleSavingRequestSuccess(articleSavingRequest: data.articleSavingRequest) + return try articleSavingRequestSuccess.decode(data: data) + case .articleSavingRequestError: + let data = Objects.ArticleSavingRequestError(errorCodes: data.errorCodes) + return try articleSavingRequestError.decode(data: data) + } + case .mocking: + return articleSavingRequestSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ArticleSavingRequestResult = Selection +} + +extension Unions { + struct CreateArticleSavingRequestResult { + let __typename: TypeName + let articleSavingRequest: [String: Objects.ArticleSavingRequest] + let errorCodes: [String: [Enums.CreateArticleSavingRequestErrorCode]] + + enum TypeName: String, Codable { + case createArticleSavingRequestSuccess = "CreateArticleSavingRequestSuccess" + case createArticleSavingRequestError = "CreateArticleSavingRequestError" + } + } +} + +extension Unions.CreateArticleSavingRequestResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "articleSavingRequest": + if let value = try container.decode(Objects.ArticleSavingRequest?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "errorCodes": + if let value = try container.decode([Enums.CreateArticleSavingRequestErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + articleSavingRequest = map["articleSavingRequest"] + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Unions.CreateArticleSavingRequestResult { + func on(createArticleSavingRequestSuccess: Selection, createArticleSavingRequestError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "CreateArticleSavingRequestSuccess", selection: createArticleSavingRequestSuccess.selection), GraphQLField.fragment(type: "CreateArticleSavingRequestError", selection: createArticleSavingRequestError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .createArticleSavingRequestSuccess: + let data = Objects.CreateArticleSavingRequestSuccess(articleSavingRequest: data.articleSavingRequest) + return try createArticleSavingRequestSuccess.decode(data: data) + case .createArticleSavingRequestError: + let data = Objects.CreateArticleSavingRequestError(errorCodes: data.errorCodes) + return try createArticleSavingRequestError.decode(data: data) + } + case .mocking: + return createArticleSavingRequestSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateArticleSavingRequestResult = Selection +} + +extension Unions { + struct SetShareHighlightResult { + let __typename: TypeName + let errorCodes: [String: [Enums.SetShareHighlightErrorCode]] + let highlight: [String: Objects.Highlight] + + enum TypeName: String, Codable { + case setShareHighlightSuccess = "SetShareHighlightSuccess" + case setShareHighlightError = "SetShareHighlightError" + } + } +} + +extension Unions.SetShareHighlightResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SetShareHighlightErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "highlight": + if let value = try container.decode(Objects.Highlight?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + highlight = map["highlight"] + } +} + +extension Fields where TypeLock == Unions.SetShareHighlightResult { + func on(setShareHighlightSuccess: Selection, setShareHighlightError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "SetShareHighlightSuccess", selection: setShareHighlightSuccess.selection), GraphQLField.fragment(type: "SetShareHighlightError", selection: setShareHighlightError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .setShareHighlightSuccess: + let data = Objects.SetShareHighlightSuccess(highlight: data.highlight) + return try setShareHighlightSuccess.decode(data: data) + case .setShareHighlightError: + let data = Objects.SetShareHighlightError(errorCodes: data.errorCodes) + return try setShareHighlightError.decode(data: data) + } + case .mocking: + return setShareHighlightSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetShareHighlightResult = Selection +} + +extension Unions { + struct UpdateLinkShareInfoResult { + let __typename: TypeName + let errorCodes: [String: [Enums.UpdateLinkShareInfoErrorCode]] + let message: [String: String] + + enum TypeName: String, Codable { + case updateLinkShareInfoSuccess = "UpdateLinkShareInfoSuccess" + case updateLinkShareInfoError = "UpdateLinkShareInfoError" + } + } +} + +extension Unions.UpdateLinkShareInfoResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdateLinkShareInfoErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "message": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + message = map["message"] + } +} + +extension Fields where TypeLock == Unions.UpdateLinkShareInfoResult { + func on(updateLinkShareInfoSuccess: Selection, updateLinkShareInfoError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "UpdateLinkShareInfoSuccess", selection: updateLinkShareInfoSuccess.selection), GraphQLField.fragment(type: "UpdateLinkShareInfoError", selection: updateLinkShareInfoError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .updateLinkShareInfoSuccess: + let data = Objects.UpdateLinkShareInfoSuccess(message: data.message) + return try updateLinkShareInfoSuccess.decode(data: data) + case .updateLinkShareInfoError: + let data = Objects.UpdateLinkShareInfoError(errorCodes: data.errorCodes) + return try updateLinkShareInfoError.decode(data: data) + } + case .mocking: + return updateLinkShareInfoSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateLinkShareInfoResult = Selection +} + +extension Unions { + struct ArchiveLinkResult { + let __typename: TypeName + let errorCodes: [String: [Enums.ArchiveLinkErrorCode]] + let linkId: [String: String] + let message: [String: String] + + enum TypeName: String, Codable { + case archiveLinkSuccess = "ArchiveLinkSuccess" + case archiveLinkError = "ArchiveLinkError" + } + } +} + +extension Unions.ArchiveLinkResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.ArchiveLinkErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "linkId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "message": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + linkId = map["linkId"] + message = map["message"] + } +} + +extension Fields where TypeLock == Unions.ArchiveLinkResult { + func on(archiveLinkSuccess: Selection, archiveLinkError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "ArchiveLinkSuccess", selection: archiveLinkSuccess.selection), GraphQLField.fragment(type: "ArchiveLinkError", selection: archiveLinkError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .archiveLinkSuccess: + let data = Objects.ArchiveLinkSuccess(linkId: data.linkId, message: data.message) + return try archiveLinkSuccess.decode(data: data) + case .archiveLinkError: + let data = Objects.ArchiveLinkError(errorCodes: data.errorCodes, message: data.message) + return try archiveLinkError.decode(data: data) + } + case .mocking: + return archiveLinkSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ArchiveLinkResult = Selection +} + +extension Unions { + struct NewsletterEmailsResult { + let __typename: TypeName + let errorCodes: [String: [Enums.NewsletterEmailsErrorCode]] + let newsletterEmails: [String: [Objects.NewsletterEmail]] + + enum TypeName: String, Codable { + case newsletterEmailsSuccess = "NewsletterEmailsSuccess" + case newsletterEmailsError = "NewsletterEmailsError" + } + } +} + +extension Unions.NewsletterEmailsResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.NewsletterEmailsErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "newsletterEmails": + if let value = try container.decode([Objects.NewsletterEmail]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + newsletterEmails = map["newsletterEmails"] + } +} + +extension Fields where TypeLock == Unions.NewsletterEmailsResult { + func on(newsletterEmailsSuccess: Selection, newsletterEmailsError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "NewsletterEmailsSuccess", selection: newsletterEmailsSuccess.selection), GraphQLField.fragment(type: "NewsletterEmailsError", selection: newsletterEmailsError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .newsletterEmailsSuccess: + let data = Objects.NewsletterEmailsSuccess(newsletterEmails: data.newsletterEmails) + return try newsletterEmailsSuccess.decode(data: data) + case .newsletterEmailsError: + let data = Objects.NewsletterEmailsError(errorCodes: data.errorCodes) + return try newsletterEmailsError.decode(data: data) + } + case .mocking: + return newsletterEmailsSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias NewsletterEmailsResult = Selection +} + +extension Unions { + struct CreateNewsletterEmailResult { + let __typename: TypeName + let errorCodes: [String: [Enums.CreateNewsletterEmailErrorCode]] + let newsletterEmail: [String: Objects.NewsletterEmail] + + enum TypeName: String, Codable { + case createNewsletterEmailSuccess = "CreateNewsletterEmailSuccess" + case createNewsletterEmailError = "CreateNewsletterEmailError" + } + } +} + +extension Unions.CreateNewsletterEmailResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.CreateNewsletterEmailErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "newsletterEmail": + if let value = try container.decode(Objects.NewsletterEmail?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + newsletterEmail = map["newsletterEmail"] + } +} + +extension Fields where TypeLock == Unions.CreateNewsletterEmailResult { + func on(createNewsletterEmailSuccess: Selection, createNewsletterEmailError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "CreateNewsletterEmailSuccess", selection: createNewsletterEmailSuccess.selection), GraphQLField.fragment(type: "CreateNewsletterEmailError", selection: createNewsletterEmailError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .createNewsletterEmailSuccess: + let data = Objects.CreateNewsletterEmailSuccess(newsletterEmail: data.newsletterEmail) + return try createNewsletterEmailSuccess.decode(data: data) + case .createNewsletterEmailError: + let data = Objects.CreateNewsletterEmailError(errorCodes: data.errorCodes) + return try createNewsletterEmailError.decode(data: data) + } + case .mocking: + return createNewsletterEmailSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateNewsletterEmailResult = Selection +} + +extension Unions { + struct DeleteNewsletterEmailResult { + let __typename: TypeName + let errorCodes: [String: [Enums.DeleteNewsletterEmailErrorCode]] + let newsletterEmail: [String: Objects.NewsletterEmail] + + enum TypeName: String, Codable { + case deleteNewsletterEmailSuccess = "DeleteNewsletterEmailSuccess" + case deleteNewsletterEmailError = "DeleteNewsletterEmailError" + } + } +} + +extension Unions.DeleteNewsletterEmailResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.DeleteNewsletterEmailErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "newsletterEmail": + if let value = try container.decode(Objects.NewsletterEmail?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + newsletterEmail = map["newsletterEmail"] + } +} + +extension Fields where TypeLock == Unions.DeleteNewsletterEmailResult { + func on(deleteNewsletterEmailSuccess: Selection, deleteNewsletterEmailError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "DeleteNewsletterEmailSuccess", selection: deleteNewsletterEmailSuccess.selection), GraphQLField.fragment(type: "DeleteNewsletterEmailError", selection: deleteNewsletterEmailError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .deleteNewsletterEmailSuccess: + let data = Objects.DeleteNewsletterEmailSuccess(newsletterEmail: data.newsletterEmail) + return try deleteNewsletterEmailSuccess.decode(data: data) + case .deleteNewsletterEmailError: + let data = Objects.DeleteNewsletterEmailError(errorCodes: data.errorCodes) + return try deleteNewsletterEmailError.decode(data: data) + } + case .mocking: + return deleteNewsletterEmailSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteNewsletterEmailResult = Selection +} + +extension Unions { + struct ReminderResult { + let __typename: TypeName + let errorCodes: [String: [Enums.ReminderErrorCode]] + let reminder: [String: Objects.Reminder] + + enum TypeName: String, Codable { + case reminderSuccess = "ReminderSuccess" + case reminderError = "ReminderError" + } + } +} + +extension Unions.ReminderResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.ReminderErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "reminder": + if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + reminder = map["reminder"] + } +} + +extension Fields where TypeLock == Unions.ReminderResult { + func on(reminderSuccess: Selection, reminderError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "ReminderSuccess", selection: reminderSuccess.selection), GraphQLField.fragment(type: "ReminderError", selection: reminderError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .reminderSuccess: + let data = Objects.ReminderSuccess(reminder: data.reminder) + return try reminderSuccess.decode(data: data) + case .reminderError: + let data = Objects.ReminderError(errorCodes: data.errorCodes) + return try reminderError.decode(data: data) + } + case .mocking: + return reminderSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias ReminderResult = Selection +} + +extension Unions { + struct CreateReminderResult { + let __typename: TypeName + let errorCodes: [String: [Enums.CreateReminderErrorCode]] + let reminder: [String: Objects.Reminder] + + enum TypeName: String, Codable { + case createReminderSuccess = "CreateReminderSuccess" + case createReminderError = "CreateReminderError" + } + } +} + +extension Unions.CreateReminderResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.CreateReminderErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "reminder": + if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + reminder = map["reminder"] + } +} + +extension Fields where TypeLock == Unions.CreateReminderResult { + func on(createReminderSuccess: Selection, createReminderError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "CreateReminderSuccess", selection: createReminderSuccess.selection), GraphQLField.fragment(type: "CreateReminderError", selection: createReminderError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .createReminderSuccess: + let data = Objects.CreateReminderSuccess(reminder: data.reminder) + return try createReminderSuccess.decode(data: data) + case .createReminderError: + let data = Objects.CreateReminderError(errorCodes: data.errorCodes) + return try createReminderError.decode(data: data) + } + case .mocking: + return createReminderSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateReminderResult = Selection +} + +extension Unions { + struct UpdateReminderResult { + let __typename: TypeName + let errorCodes: [String: [Enums.UpdateReminderErrorCode]] + let reminder: [String: Objects.Reminder] + + enum TypeName: String, Codable { + case updateReminderSuccess = "UpdateReminderSuccess" + case updateReminderError = "UpdateReminderError" + } + } +} + +extension Unions.UpdateReminderResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdateReminderErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "reminder": + if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + reminder = map["reminder"] + } +} + +extension Fields where TypeLock == Unions.UpdateReminderResult { + func on(updateReminderSuccess: Selection, updateReminderError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "UpdateReminderSuccess", selection: updateReminderSuccess.selection), GraphQLField.fragment(type: "UpdateReminderError", selection: updateReminderError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .updateReminderSuccess: + let data = Objects.UpdateReminderSuccess(reminder: data.reminder) + return try updateReminderSuccess.decode(data: data) + case .updateReminderError: + let data = Objects.UpdateReminderError(errorCodes: data.errorCodes) + return try updateReminderError.decode(data: data) + } + case .mocking: + return updateReminderSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateReminderResult = Selection +} + +extension Unions { + struct DeleteReminderResult { + let __typename: TypeName + let errorCodes: [String: [Enums.DeleteReminderErrorCode]] + let reminder: [String: Objects.Reminder] + + enum TypeName: String, Codable { + case deleteReminderSuccess = "DeleteReminderSuccess" + case deleteReminderError = "DeleteReminderError" + } + } +} + +extension Unions.DeleteReminderResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.DeleteReminderErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "reminder": + if let value = try container.decode(Objects.Reminder?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + reminder = map["reminder"] + } +} + +extension Fields where TypeLock == Unions.DeleteReminderResult { + func on(deleteReminderSuccess: Selection, deleteReminderError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "DeleteReminderSuccess", selection: deleteReminderSuccess.selection), GraphQLField.fragment(type: "DeleteReminderError", selection: deleteReminderError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .deleteReminderSuccess: + let data = Objects.DeleteReminderSuccess(reminder: data.reminder) + return try deleteReminderSuccess.decode(data: data) + case .deleteReminderError: + let data = Objects.DeleteReminderError(errorCodes: data.errorCodes) + return try deleteReminderError.decode(data: data) + } + case .mocking: + return deleteReminderSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteReminderResult = Selection +} + +extension Unions { + struct SetDeviceTokenResult { + let __typename: TypeName + let deviceToken: [String: Objects.DeviceToken] + let errorCodes: [String: [Enums.SetDeviceTokenErrorCode]] + + enum TypeName: String, Codable { + case setDeviceTokenSuccess = "SetDeviceTokenSuccess" + case setDeviceTokenError = "SetDeviceTokenError" + } + } +} + +extension Unions.SetDeviceTokenResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "deviceToken": + if let value = try container.decode(Objects.DeviceToken?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "errorCodes": + if let value = try container.decode([Enums.SetDeviceTokenErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + deviceToken = map["deviceToken"] + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Unions.SetDeviceTokenResult { + func on(setDeviceTokenSuccess: Selection, setDeviceTokenError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "SetDeviceTokenSuccess", selection: setDeviceTokenSuccess.selection), GraphQLField.fragment(type: "SetDeviceTokenError", selection: setDeviceTokenError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .setDeviceTokenSuccess: + let data = Objects.SetDeviceTokenSuccess(deviceToken: data.deviceToken) + return try setDeviceTokenSuccess.decode(data: data) + case .setDeviceTokenError: + let data = Objects.SetDeviceTokenError(errorCodes: data.errorCodes) + return try setDeviceTokenError.decode(data: data) + } + case .mocking: + return setDeviceTokenSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetDeviceTokenResult = Selection +} + +extension Unions { + struct LabelsResult { + let __typename: TypeName + let errorCodes: [String: [Enums.LabelsErrorCode]] + let labels: [String: [Objects.Label]] + + enum TypeName: String, Codable { + case labelsSuccess = "LabelsSuccess" + case labelsError = "LabelsError" + } + } +} + +extension Unions.LabelsResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.LabelsErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "labels": + if let value = try container.decode([Objects.Label]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + labels = map["labels"] + } +} + +extension Fields where TypeLock == Unions.LabelsResult { + func on(labelsSuccess: Selection, labelsError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "LabelsSuccess", selection: labelsSuccess.selection), GraphQLField.fragment(type: "LabelsError", selection: labelsError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .labelsSuccess: + let data = Objects.LabelsSuccess(labels: data.labels) + return try labelsSuccess.decode(data: data) + case .labelsError: + let data = Objects.LabelsError(errorCodes: data.errorCodes) + return try labelsError.decode(data: data) + } + case .mocking: + return labelsSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias LabelsResult = Selection +} + +extension Unions { + struct CreateLabelResult { + let __typename: TypeName + let errorCodes: [String: [Enums.CreateLabelErrorCode]] + let label: [String: Objects.Label] + + enum TypeName: String, Codable { + case createLabelSuccess = "CreateLabelSuccess" + case createLabelError = "CreateLabelError" + } + } +} + +extension Unions.CreateLabelResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.CreateLabelErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "label": + if let value = try container.decode(Objects.Label?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + label = map["label"] + } +} + +extension Fields where TypeLock == Unions.CreateLabelResult { + func on(createLabelSuccess: Selection, createLabelError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "CreateLabelSuccess", selection: createLabelSuccess.selection), GraphQLField.fragment(type: "CreateLabelError", selection: createLabelError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .createLabelSuccess: + let data = Objects.CreateLabelSuccess(label: data.label) + return try createLabelSuccess.decode(data: data) + case .createLabelError: + let data = Objects.CreateLabelError(errorCodes: data.errorCodes) + return try createLabelError.decode(data: data) + } + case .mocking: + return createLabelSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias CreateLabelResult = Selection +} + +extension Unions { + struct DeleteLabelResult { + let __typename: TypeName + let errorCodes: [String: [Enums.DeleteLabelErrorCode]] + let label: [String: Objects.Label] + + enum TypeName: String, Codable { + case deleteLabelSuccess = "DeleteLabelSuccess" + case deleteLabelError = "DeleteLabelError" + } + } +} + +extension Unions.DeleteLabelResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.DeleteLabelErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "label": + if let value = try container.decode(Objects.Label?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + label = map["label"] + } +} + +extension Fields where TypeLock == Unions.DeleteLabelResult { + func on(deleteLabelSuccess: Selection, deleteLabelError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "DeleteLabelSuccess", selection: deleteLabelSuccess.selection), GraphQLField.fragment(type: "DeleteLabelError", selection: deleteLabelError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .deleteLabelSuccess: + let data = Objects.DeleteLabelSuccess(label: data.label) + return try deleteLabelSuccess.decode(data: data) + case .deleteLabelError: + let data = Objects.DeleteLabelError(errorCodes: data.errorCodes) + return try deleteLabelError.decode(data: data) + } + case .mocking: + return deleteLabelSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteLabelResult = Selection +} + +extension Unions { + struct UpdateLabelResult { + let __typename: TypeName + let errorCodes: [String: [Enums.UpdateLabelErrorCode]] + let label: [String: Objects.Label] + + enum TypeName: String, Codable { + case updateLabelSuccess = "UpdateLabelSuccess" + case updateLabelError = "UpdateLabelError" + } + } +} + +extension Unions.UpdateLabelResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UpdateLabelErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "label": + if let value = try container.decode(Objects.Label?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + label = map["label"] + } +} + +extension Fields where TypeLock == Unions.UpdateLabelResult { + func on(updateLabelSuccess: Selection, updateLabelError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "UpdateLabelSuccess", selection: updateLabelSuccess.selection), GraphQLField.fragment(type: "UpdateLabelError", selection: updateLabelError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .updateLabelSuccess: + let data = Objects.UpdateLabelSuccess(label: data.label) + return try updateLabelSuccess.decode(data: data) + case .updateLabelError: + let data = Objects.UpdateLabelError(errorCodes: data.errorCodes) + return try updateLabelError.decode(data: data) + } + case .mocking: + return updateLabelSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UpdateLabelResult = Selection +} + +extension Unions { + struct SignupResult { + let __typename: TypeName + let errorCodes: [String: [Enums.SignupErrorCode?]] + let me: [String: Objects.User] + + enum TypeName: String, Codable { + case signupSuccess = "SignupSuccess" + case signupError = "SignupError" + } + } +} + +extension Unions.SignupResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SignupErrorCode?]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "me": + if let value = try container.decode(Objects.User?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + me = map["me"] + } +} + +extension Fields where TypeLock == Unions.SignupResult { + func on(signupSuccess: Selection, signupError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "SignupSuccess", selection: signupSuccess.selection), GraphQLField.fragment(type: "SignupError", selection: signupError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .signupSuccess: + let data = Objects.SignupSuccess(me: data.me) + return try signupSuccess.decode(data: data) + case .signupError: + let data = Objects.SignupError(errorCodes: data.errorCodes) + return try signupError.decode(data: data) + } + case .mocking: + return signupSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SignupResult = Selection +} + +extension Unions { + struct SetLabelsResult { + let __typename: TypeName + let errorCodes: [String: [Enums.SetLabelsErrorCode]] + let labels: [String: [Objects.Label]] + + enum TypeName: String, Codable { + case setLabelsSuccess = "SetLabelsSuccess" + case setLabelsError = "SetLabelsError" + } + } +} + +extension Unions.SetLabelsResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SetLabelsErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "labels": + if let value = try container.decode([Objects.Label]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + labels = map["labels"] + } +} + +extension Fields where TypeLock == Unions.SetLabelsResult { + func on(setLabelsSuccess: Selection, setLabelsError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "SetLabelsSuccess", selection: setLabelsSuccess.selection), GraphQLField.fragment(type: "SetLabelsError", selection: setLabelsError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .setLabelsSuccess: + let data = Objects.SetLabelsSuccess(labels: data.labels) + return try setLabelsSuccess.decode(data: data) + case .setLabelsError: + let data = Objects.SetLabelsError(errorCodes: data.errorCodes) + return try setLabelsError.decode(data: data) + } + case .mocking: + return setLabelsSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetLabelsResult = Selection +} + +extension Unions { + struct GenerateApiKeyResult { + let __typename: TypeName + let apiKey: [String: String] + let errorCodes: [String: [Enums.GenerateApiKeyErrorCode]] + + enum TypeName: String, Codable { + case generateApiKeySuccess = "GenerateApiKeySuccess" + case generateApiKeyError = "GenerateApiKeyError" + } + } +} + +extension Unions.GenerateApiKeyResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "apiKey": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "errorCodes": + if let value = try container.decode([Enums.GenerateApiKeyErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + apiKey = map["apiKey"] + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Unions.GenerateApiKeyResult { + func on(generateApiKeySuccess: Selection, generateApiKeyError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "GenerateApiKeySuccess", selection: generateApiKeySuccess.selection), GraphQLField.fragment(type: "GenerateApiKeyError", selection: generateApiKeyError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .generateApiKeySuccess: + let data = Objects.GenerateApiKeySuccess(apiKey: data.apiKey) + return try generateApiKeySuccess.decode(data: data) + case .generateApiKeyError: + let data = Objects.GenerateApiKeyError(errorCodes: data.errorCodes) + return try generateApiKeyError.decode(data: data) + } + case .mocking: + return generateApiKeySuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias GenerateApiKeyResult = Selection +} + +extension Unions { + struct SearchResult { + let __typename: TypeName + let edges: [String: [Objects.SearchItemEdge]] + let errorCodes: [String: [Enums.SearchErrorCode]] + let pageInfo: [String: Objects.PageInfo] + + enum TypeName: String, Codable { + case searchSuccess = "SearchSuccess" + case searchError = "SearchError" + } + } +} + +extension Unions.SearchResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "edges": + if let value = try container.decode([Objects.SearchItemEdge]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "errorCodes": + if let value = try container.decode([Enums.SearchErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "pageInfo": + if let value = try container.decode(Objects.PageInfo?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + edges = map["edges"] + errorCodes = map["errorCodes"] + pageInfo = map["pageInfo"] + } +} + +extension Fields where TypeLock == Unions.SearchResult { + func on(searchSuccess: Selection, searchError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "SearchSuccess", selection: searchSuccess.selection), GraphQLField.fragment(type: "SearchError", selection: searchError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .searchSuccess: + let data = Objects.SearchSuccess(edges: data.edges, pageInfo: data.pageInfo) + return try searchSuccess.decode(data: data) + case .searchError: + let data = Objects.SearchError(errorCodes: data.errorCodes) + return try searchError.decode(data: data) + } + case .mocking: + return searchSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SearchResult = Selection +} + +extension Unions { + struct SubscriptionsResult { + let __typename: TypeName + let errorCodes: [String: [Enums.SubscriptionsErrorCode]] + let subscriptions: [String: [Objects.Subscription]] + + enum TypeName: String, Codable { + case subscriptionsSuccess = "SubscriptionsSuccess" + case subscriptionsError = "SubscriptionsError" + } + } +} + +extension Unions.SubscriptionsResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SubscriptionsErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "subscriptions": + if let value = try container.decode([Objects.Subscription]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + subscriptions = map["subscriptions"] + } +} + +extension Fields where TypeLock == Unions.SubscriptionsResult { + func on(subscriptionsSuccess: Selection, subscriptionsError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "SubscriptionsSuccess", selection: subscriptionsSuccess.selection), GraphQLField.fragment(type: "SubscriptionsError", selection: subscriptionsError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .subscriptionsSuccess: + let data = Objects.SubscriptionsSuccess(subscriptions: data.subscriptions) + return try subscriptionsSuccess.decode(data: data) + case .subscriptionsError: + let data = Objects.SubscriptionsError(errorCodes: data.errorCodes) + return try subscriptionsError.decode(data: data) + } + case .mocking: + return subscriptionsSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SubscriptionsResult = Selection +} + +extension Unions { + struct UnsubscribeResult { + let __typename: TypeName + let errorCodes: [String: [Enums.UnsubscribeErrorCode]] + let subscription: [String: Objects.Subscription] + + enum TypeName: String, Codable { + case unsubscribeSuccess = "UnsubscribeSuccess" + case unsubscribeError = "UnsubscribeError" + } + } +} + +extension Unions.UnsubscribeResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.UnsubscribeErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "subscription": + if let value = try container.decode(Objects.Subscription?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + subscription = map["subscription"] + } +} + +extension Fields where TypeLock == Unions.UnsubscribeResult { + func on(unsubscribeSuccess: Selection, unsubscribeError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "UnsubscribeSuccess", selection: unsubscribeSuccess.selection), GraphQLField.fragment(type: "UnsubscribeError", selection: unsubscribeError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .unsubscribeSuccess: + let data = Objects.UnsubscribeSuccess(subscription: data.subscription) + return try unsubscribeSuccess.decode(data: data) + case .unsubscribeError: + let data = Objects.UnsubscribeError(errorCodes: data.errorCodes) + return try unsubscribeError.decode(data: data) + } + case .mocking: + return unsubscribeSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias UnsubscribeResult = Selection +} + +extension Unions { + struct SubscribeResult { + let __typename: TypeName + let errorCodes: [String: [Enums.SubscribeErrorCode]] + let subscriptions: [String: [Objects.Subscription]] + + enum TypeName: String, Codable { + case subscribeSuccess = "SubscribeSuccess" + case subscribeError = "SubscribeError" + } + } +} + +extension Unions.SubscribeResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SubscribeErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "subscriptions": + if let value = try container.decode([Objects.Subscription]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + subscriptions = map["subscriptions"] + } +} + +extension Fields where TypeLock == Unions.SubscribeResult { + func on(subscribeSuccess: Selection, subscribeError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "SubscribeSuccess", selection: subscribeSuccess.selection), GraphQLField.fragment(type: "SubscribeError", selection: subscribeError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .subscribeSuccess: + let data = Objects.SubscribeSuccess(subscriptions: data.subscriptions) + return try subscribeSuccess.decode(data: data) + case .subscribeError: + let data = Objects.SubscribeError(errorCodes: data.errorCodes) + return try subscribeError.decode(data: data) + } + case .mocking: + return subscribeSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SubscribeResult = Selection +} + +extension Unions { + struct AddPopularReadResult { + let __typename: TypeName + let errorCodes: [String: [Enums.AddPopularReadErrorCode]] + let pageId: [String: String] + + enum TypeName: String, Codable { + case addPopularReadSuccess = "AddPopularReadSuccess" + case addPopularReadError = "AddPopularReadError" + } + } +} + +extension Unions.AddPopularReadResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.AddPopularReadErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "pageId": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + __typename = try container.decode(TypeName.self, forKey: DynamicCodingKeys(stringValue: "__typename")!) + + errorCodes = map["errorCodes"] + pageId = map["pageId"] + } +} + +extension Fields where TypeLock == Unions.AddPopularReadResult { + func on(addPopularReadSuccess: Selection, addPopularReadError: Selection) throws -> Type { + select([GraphQLField.fragment(type: "AddPopularReadSuccess", selection: addPopularReadSuccess.selection), GraphQLField.fragment(type: "AddPopularReadError", selection: addPopularReadError.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .addPopularReadSuccess: + let data = Objects.AddPopularReadSuccess(pageId: data.pageId) + return try addPopularReadSuccess.decode(data: data) + case .addPopularReadError: + let data = Objects.AddPopularReadError(errorCodes: data.errorCodes) + return try addPopularReadError.decode(data: data) + } + case .mocking: + return addPopularReadSuccess.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias AddPopularReadResult = Selection } // MARK: - Enums enum Enums {} extension Enums { - /// AddPopularReadErrorCode - enum AddPopularReadErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" + /// SortOrder + enum SortOrder: String, CaseIterable, Codable { + case ascending = "ASCENDING" - case notFound = "NOT_FOUND" + case descending = "DESCENDING" + } +} + +extension Enums { + /// ReactionType + enum ReactionType: String, CaseIterable, Codable { + case like = "LIKE" + + case heart = "HEART" + + case smile = "SMILE" + + case hushed = "HUSHED" + + case crying = "CRYING" + + case pout = "POUT" + } +} + +extension Enums { + /// SortBy + enum SortBy: String, CaseIterable, Codable { + case updatedTime = "UPDATED_TIME" + + case score = "SCORE" + + case savedAt = "SAVED_AT" + + case publishedAt = "PUBLISHED_AT" + } +} + +extension Enums { + /// ContentReader + enum ContentReader: String, CaseIterable, Codable { + case web = "WEB" + + case pdf = "PDF" + } +} + +extension Enums { + /// UserErrorCode + enum UserErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case userNotFound = "USER_NOT_FOUND" + + case badRequest = "BAD_REQUEST" + } +} + +extension Enums { + /// UsersErrorCode + enum UsersErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + } +} + +extension Enums { + /// LoginErrorCode + enum LoginErrorCode: String, CaseIterable, Codable { + case authFailed = "AUTH_FAILED" + + case userAlreadyExists = "USER_ALREADY_EXISTS" + + case invalidCredentials = "INVALID_CREDENTIALS" + + case userNotFound = "USER_NOT_FOUND" + + case wrongSource = "WRONG_SOURCE" + + case accessDenied = "ACCESS_DENIED" + } +} + +extension Enums { + /// SignupErrorCode + enum SignupErrorCode: String, CaseIterable, Codable { + case unknown = "UNKNOWN" + + case accessDenied = "ACCESS_DENIED" + + case googleAuthError = "GOOGLE_AUTH_ERROR" + + case invalidUsername = "INVALID_USERNAME" + + case userExists = "USER_EXISTS" + + case expiredToken = "EXPIRED_TOKEN" + + case invalidPassword = "INVALID_PASSWORD" + } +} + +extension Enums { + /// LogOutErrorCode + enum LogOutErrorCode: String, CaseIterable, Codable { + case logOutFailed = "LOG_OUT_FAILED" + } +} + +extension Enums { + /// UpdateUserErrorCode + enum UpdateUserErrorCode: String, CaseIterable, Codable { + case emptyName = "EMPTY_NAME" + + case bioTooLong = "BIO_TOO_LONG" + + case userNotFound = "USER_NOT_FOUND" case unauthorized = "UNAUTHORIZED" } } extension Enums { - /// ArchiveLinkErrorCode - enum ArchiveLinkErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" - + /// UpdateUserProfileErrorCode + enum UpdateUserProfileErrorCode: String, CaseIterable, Codable { case unauthorized = "UNAUTHORIZED" + + case forbidden = "FORBIDDEN" + + case badData = "BAD_DATA" + + case badUsername = "BAD_USERNAME" + + case usernameExists = "USERNAME_EXISTS" + } +} + +extension Enums { + /// PageType + enum PageType: String, CaseIterable, Codable { + case article = "ARTICLE" + + case book = "BOOK" + + case file = "FILE" + + case profile = "PROFILE" + + case website = "WEBSITE" + + case highlights = "HIGHLIGHTS" + + case unknown = "UNKNOWN" } } extension Enums { /// ArticleErrorCode enum ArticleErrorCode: String, CaseIterable, Codable { + case notFound = "NOT_FOUND" + case badData = "BAD_DATA" - case notFound = "NOT_FOUND" - case unauthorized = "UNAUTHORIZED" } } extension Enums { - /// ArticleSavingRequestErrorCode - enum ArticleSavingRequestErrorCode: String, CaseIterable, Codable { + /// SharedArticleErrorCode + enum SharedArticleErrorCode: String, CaseIterable, Codable { case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// ArticleSavingRequestStatus - enum ArticleSavingRequestStatus: String, CaseIterable, Codable { - case failed = "FAILED" - - case processing = "PROCESSING" - - case succeeded = "SUCCEEDED" } } @@ -19817,181 +19982,209 @@ extension Enums { } extension Enums { - /// ContentReader - enum ContentReader: String, CaseIterable, Codable { - case pdf = "PDF" + /// UploadFileStatus + enum UploadFileStatus: String, CaseIterable, Codable { + case initialized = "INITIALIZED" - case web = "WEB" + case completed = "COMPLETED" + } +} + +extension Enums { + /// UploadFileRequestErrorCode + enum UploadFileRequestErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case badInput = "BAD_INPUT" + + case failedCreate = "FAILED_CREATE" } } extension Enums { /// CreateArticleErrorCode enum CreateArticleErrorCode: String, CaseIterable, Codable { - case elasticError = "ELASTIC_ERROR" - - case notAllowedToParse = "NOT_ALLOWED_TO_PARSE" - - case payloadTooLarge = "PAYLOAD_TOO_LARGE" - case unableToFetch = "UNABLE_TO_FETCH" case unableToParse = "UNABLE_TO_PARSE" case unauthorized = "UNAUTHORIZED" + case notAllowedToParse = "NOT_ALLOWED_TO_PARSE" + + case payloadTooLarge = "PAYLOAD_TOO_LARGE" + case uploadFileMissing = "UPLOAD_FILE_MISSING" + + case elasticError = "ELASTIC_ERROR" } } extension Enums { - /// CreateArticleSavingRequestErrorCode - enum CreateArticleSavingRequestErrorCode: String, CaseIterable, Codable { + /// SaveErrorCode + enum SaveErrorCode: String, CaseIterable, Codable { + case unknown = "UNKNOWN" + + case unauthorized = "UNAUTHORIZED" + } +} + +extension Enums { + /// UpdatePageErrorCode + enum UpdatePageErrorCode: String, CaseIterable, Codable { + case updateFailed = "UPDATE_FAILED" + + case unauthorized = "UNAUTHORIZED" + + case badRequest = "BAD_REQUEST" + + case notFound = "NOT_FOUND" + + case forbidden = "FORBIDDEN" + } +} + +extension Enums { + /// SetFollowErrorCode + enum SetFollowErrorCode: String, CaseIterable, Codable { + case notFound = "NOT_FOUND" + + case unauthorized = "UNAUTHORIZED" + } +} + +extension Enums { + /// SaveArticleReadingProgressErrorCode + enum SaveArticleReadingProgressErrorCode: String, CaseIterable, Codable { + case notFound = "NOT_FOUND" + case badData = "BAD_DATA" case unauthorized = "UNAUTHORIZED" } } +extension Enums { + /// SetBookmarkArticleErrorCode + enum SetBookmarkArticleErrorCode: String, CaseIterable, Codable { + case notFound = "NOT_FOUND" + + case bookmarkExists = "BOOKMARK_EXISTS" + } +} + extension Enums { /// CreateHighlightErrorCode enum CreateHighlightErrorCode: String, CaseIterable, Codable { - case alreadyExists = "ALREADY_EXISTS" + case unauthorized = "UNAUTHORIZED" + + case forbidden = "FORBIDDEN" case badData = "BAD_DATA" - case forbidden = "FORBIDDEN" - case notFound = "NOT_FOUND" - case unauthorized = "UNAUTHORIZED" + case alreadyExists = "ALREADY_EXISTS" } } extension Enums { - /// CreateHighlightReplyErrorCode - enum CreateHighlightReplyErrorCode: String, CaseIterable, Codable { - case emptyAnnotation = "EMPTY_ANNOTATION" + /// MergeHighlightErrorCode + enum MergeHighlightErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case forbidden = "FORBIDDEN" + + case badData = "BAD_DATA" + + case notFound = "NOT_FOUND" + + case alreadyExists = "ALREADY_EXISTS" + } +} + +extension Enums { + /// UpdateHighlightErrorCode + enum UpdateHighlightErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" case forbidden = "FORBIDDEN" case notFound = "NOT_FOUND" - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// CreateLabelErrorCode - enum CreateLabelErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" - - case labelAlreadyExists = "LABEL_ALREADY_EXISTS" - - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// CreateNewsletterEmailErrorCode - enum CreateNewsletterEmailErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// CreateReactionErrorCode - enum CreateReactionErrorCode: String, CaseIterable, Codable { - case badCode = "BAD_CODE" - - case badTarget = "BAD_TARGET" - - case forbidden = "FORBIDDEN" - - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// CreateReminderErrorCode - enum CreateReminderErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" - - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" + case badData = "BAD_DATA" } } extension Enums { /// DeleteHighlightErrorCode enum DeleteHighlightErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case forbidden = "FORBIDDEN" + + case notFound = "NOT_FOUND" + } +} + +extension Enums { + /// CreateHighlightReplyErrorCode + enum CreateHighlightReplyErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + case forbidden = "FORBIDDEN" case notFound = "NOT_FOUND" + case emptyAnnotation = "EMPTY_ANNOTATION" + } +} + +extension Enums { + /// UpdateHighlightReplyErrorCode + enum UpdateHighlightReplyErrorCode: String, CaseIterable, Codable { case unauthorized = "UNAUTHORIZED" + + case forbidden = "FORBIDDEN" + + case notFound = "NOT_FOUND" } } extension Enums { /// DeleteHighlightReplyErrorCode enum DeleteHighlightReplyErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + case forbidden = "FORBIDDEN" case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" } } extension Enums { - /// DeleteLabelErrorCode - enum DeleteLabelErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" + /// CreateReactionErrorCode + enum CreateReactionErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case forbidden = "FORBIDDEN" + + case badTarget = "BAD_TARGET" + + case badCode = "BAD_CODE" case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// DeleteNewsletterEmailErrorCode - enum DeleteNewsletterEmailErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" - - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" } } extension Enums { /// DeleteReactionErrorCode enum DeleteReactionErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + case forbidden = "FORBIDDEN" case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// DeleteReminderErrorCode - enum DeleteReminderErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" - - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" } } @@ -20003,9 +20196,20 @@ extension Enums { } extension Enums { - /// GenerateApiKeyErrorCode - enum GenerateApiKeyErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" + /// SetShareArticleErrorCode + enum SetShareArticleErrorCode: String, CaseIterable, Codable { + case notFound = "NOT_FOUND" + + case unauthorized = "UNAUTHORIZED" + } +} + +extension Enums { + /// UpdateSharedCommentErrorCode + enum UpdateSharedCommentErrorCode: String, CaseIterable, Codable { + case notFound = "NOT_FOUND" + + case unauthorized = "UNAUTHORIZED" } } @@ -20031,141 +20235,230 @@ extension Enums { } extension Enums { - /// LabelsErrorCode - enum LabelsErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" - - case notFound = "NOT_FOUND" - + /// SetUserPersonalizationErrorCode + enum SetUserPersonalizationErrorCode: String, CaseIterable, Codable { case unauthorized = "UNAUTHORIZED" } } extension Enums { - /// LoginErrorCode - enum LoginErrorCode: String, CaseIterable, Codable { - case accessDenied = "ACCESS_DENIED" + /// ArticleSavingRequestStatus + enum ArticleSavingRequestStatus: String, CaseIterable, Codable { + case processing = "PROCESSING" - case authFailed = "AUTH_FAILED" + case succeeded = "SUCCEEDED" - case invalidCredentials = "INVALID_CREDENTIALS" - - case userAlreadyExists = "USER_ALREADY_EXISTS" - - case userNotFound = "USER_NOT_FOUND" - - case wrongSource = "WRONG_SOURCE" + case failed = "FAILED" } } extension Enums { - /// LogOutErrorCode - enum LogOutErrorCode: String, CaseIterable, Codable { - case logOutFailed = "LOG_OUT_FAILED" + /// ArticleSavingRequestErrorCode + enum ArticleSavingRequestErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case notFound = "NOT_FOUND" } } extension Enums { - /// MergeHighlightErrorCode - enum MergeHighlightErrorCode: String, CaseIterable, Codable { - case alreadyExists = "ALREADY_EXISTS" + /// CreateArticleSavingRequestErrorCode + enum CreateArticleSavingRequestErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" case badData = "BAD_DATA" + } +} + +extension Enums { + /// SetShareHighlightErrorCode + enum SetShareHighlightErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case notFound = "NOT_FOUND" case forbidden = "FORBIDDEN" - - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// NewsletterEmailsErrorCode - enum NewsletterEmailsErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// PageType - enum PageType: String, CaseIterable, Codable { - case article = "ARTICLE" - - case book = "BOOK" - - case file = "FILE" - - case highlights = "HIGHLIGHTS" - - case profile = "PROFILE" - - case unknown = "UNKNOWN" - - case website = "WEBSITE" - } -} - -extension Enums { - /// ReactionType - enum ReactionType: String, CaseIterable, Codable { - case crying = "CRYING" - - case heart = "HEART" - - case hushed = "HUSHED" - - case like = "LIKE" - - case pout = "POUT" - - case smile = "SMILE" - } -} - -extension Enums { - /// ReminderErrorCode - enum ReminderErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" - - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" } } extension Enums { /// ReportType enum ReportType: String, CaseIterable, Codable { + case spam = "SPAM" + case abusive = "ABUSIVE" case contentDisplay = "CONTENT_DISPLAY" case contentViolation = "CONTENT_VIOLATION" - - case spam = "SPAM" } } extension Enums { - /// SaveArticleReadingProgressErrorCode - enum SaveArticleReadingProgressErrorCode: String, CaseIterable, Codable { - case badData = "BAD_DATA" + /// UpdateLinkShareInfoErrorCode + enum UpdateLinkShareInfoErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case badRequest = "BAD_REQUEST" + } +} + +extension Enums { + /// ArchiveLinkErrorCode + enum ArchiveLinkErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case badRequest = "BAD_REQUEST" + } +} + +extension Enums { + /// NewsletterEmailsErrorCode + enum NewsletterEmailsErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case badRequest = "BAD_REQUEST" + } +} + +extension Enums { + /// CreateNewsletterEmailErrorCode + enum CreateNewsletterEmailErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case badRequest = "BAD_REQUEST" + } +} + +extension Enums { + /// DeleteNewsletterEmailErrorCode + enum DeleteNewsletterEmailErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case badRequest = "BAD_REQUEST" + + case notFound = "NOT_FOUND" + } +} + +extension Enums { + /// ReminderErrorCode + enum ReminderErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case badRequest = "BAD_REQUEST" + + case notFound = "NOT_FOUND" + } +} + +extension Enums { + /// CreateReminderErrorCode + enum CreateReminderErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case badRequest = "BAD_REQUEST" + + case notFound = "NOT_FOUND" + } +} + +extension Enums { + /// UpdateReminderErrorCode + enum UpdateReminderErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case badRequest = "BAD_REQUEST" + + case notFound = "NOT_FOUND" + } +} + +extension Enums { + /// DeleteReminderErrorCode + enum DeleteReminderErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case badRequest = "BAD_REQUEST" + + case notFound = "NOT_FOUND" + } +} + +extension Enums { + /// SetDeviceTokenErrorCode + enum SetDeviceTokenErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case badRequest = "BAD_REQUEST" + + case notFound = "NOT_FOUND" + } +} + +extension Enums { + /// LabelsErrorCode + enum LabelsErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case badRequest = "BAD_REQUEST" + + case notFound = "NOT_FOUND" + } +} + +extension Enums { + /// CreateLabelErrorCode + enum CreateLabelErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case badRequest = "BAD_REQUEST" case notFound = "NOT_FOUND" - case unauthorized = "UNAUTHORIZED" + case labelAlreadyExists = "LABEL_ALREADY_EXISTS" } } extension Enums { - /// SaveErrorCode - enum SaveErrorCode: String, CaseIterable, Codable { + /// DeleteLabelErrorCode + enum DeleteLabelErrorCode: String, CaseIterable, Codable { case unauthorized = "UNAUTHORIZED" - case unknown = "UNKNOWN" + case badRequest = "BAD_REQUEST" + + case notFound = "NOT_FOUND" + } +} + +extension Enums { + /// UpdateLabelErrorCode + enum UpdateLabelErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case badRequest = "BAD_REQUEST" + + case notFound = "NOT_FOUND" + + case forbidden = "FORBIDDEN" + } +} + +extension Enums { + /// SetLabelsErrorCode + enum SetLabelsErrorCode: String, CaseIterable, Codable { + case unauthorized = "UNAUTHORIZED" + + case badRequest = "BAD_REQUEST" + + case notFound = "NOT_FOUND" + } +} + +extension Enums { + /// GenerateApiKeyErrorCode + enum GenerateApiKeyErrorCode: String, CaseIterable, Codable { + case badRequest = "BAD_REQUEST" } } @@ -20177,312 +20470,61 @@ extension Enums { } extension Enums { - /// SetBookmarkArticleErrorCode - enum SetBookmarkArticleErrorCode: String, CaseIterable, Codable { - case bookmarkExists = "BOOKMARK_EXISTS" + /// SubscriptionStatus + enum SubscriptionStatus: String, CaseIterable, Codable { + case active = "ACTIVE" - case notFound = "NOT_FOUND" - } -} + case unsubscribed = "UNSUBSCRIBED" -extension Enums { - /// SetDeviceTokenErrorCode - enum SetDeviceTokenErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" - - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// SetFollowErrorCode - enum SetFollowErrorCode: String, CaseIterable, Codable { - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// SetLabelsErrorCode - enum SetLabelsErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" - - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// SetShareArticleErrorCode - enum SetShareArticleErrorCode: String, CaseIterable, Codable { - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// SetShareHighlightErrorCode - enum SetShareHighlightErrorCode: String, CaseIterable, Codable { - case forbidden = "FORBIDDEN" - - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// SetUserPersonalizationErrorCode - enum SetUserPersonalizationErrorCode: String, CaseIterable, Codable { - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// SharedArticleErrorCode - enum SharedArticleErrorCode: String, CaseIterable, Codable { - case notFound = "NOT_FOUND" - } -} - -extension Enums { - /// SignupErrorCode - enum SignupErrorCode: String, CaseIterable, Codable { - case accessDenied = "ACCESS_DENIED" - - case expiredToken = "EXPIRED_TOKEN" - - case googleAuthError = "GOOGLE_AUTH_ERROR" - - case invalidPassword = "INVALID_PASSWORD" - - case invalidUsername = "INVALID_USERNAME" - - case unknown = "UNKNOWN" - - case userExists = "USER_EXISTS" - } -} - -extension Enums { - /// SortBy - enum SortBy: String, CaseIterable, Codable { - case publishedAt = "PUBLISHED_AT" - - case savedAt = "SAVED_AT" - - case score = "SCORE" - - case updatedTime = "UPDATED_TIME" - } -} - -extension Enums { - /// SortOrder - enum SortOrder: String, CaseIterable, Codable { - case ascending = "ASCENDING" - - case descending = "DESCENDING" - } -} - -extension Enums { - /// SubscribeErrorCode - enum SubscribeErrorCode: String, CaseIterable, Codable { - case alreadySubscribed = "ALREADY_SUBSCRIBED" - - case badRequest = "BAD_REQUEST" - - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" + case deleted = "DELETED" } } extension Enums { /// SubscriptionsErrorCode enum SubscriptionsErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" - case unauthorized = "UNAUTHORIZED" - } -} -extension Enums { - /// SubscriptionStatus - enum SubscriptionStatus: String, CaseIterable, Codable { - case active = "ACTIVE" - - case deleted = "DELETED" - - case unsubscribed = "UNSUBSCRIBED" + case badRequest = "BAD_REQUEST" } } extension Enums { /// UnsubscribeErrorCode enum UnsubscribeErrorCode: String, CaseIterable, Codable { - case alreadyUnsubscribed = "ALREADY_UNSUBSCRIBED" + case unauthorized = "UNAUTHORIZED" case badRequest = "BAD_REQUEST" case notFound = "NOT_FOUND" - case unauthorized = "UNAUTHORIZED" + case alreadyUnsubscribed = "ALREADY_UNSUBSCRIBED" case unsubscribeMethodNotFound = "UNSUBSCRIBE_METHOD_NOT_FOUND" } } extension Enums { - /// UpdateHighlightErrorCode - enum UpdateHighlightErrorCode: String, CaseIterable, Codable { - case badData = "BAD_DATA" - - case forbidden = "FORBIDDEN" - - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// UpdateHighlightReplyErrorCode - enum UpdateHighlightReplyErrorCode: String, CaseIterable, Codable { - case forbidden = "FORBIDDEN" - - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// UpdateLabelErrorCode - enum UpdateLabelErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" - - case forbidden = "FORBIDDEN" - - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// UpdateLinkShareInfoErrorCode - enum UpdateLinkShareInfoErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// UpdatePageErrorCode - enum UpdatePageErrorCode: String, CaseIterable, Codable { - case badRequest = "BAD_REQUEST" - - case forbidden = "FORBIDDEN" - - case notFound = "NOT_FOUND" - + /// SubscribeErrorCode + enum SubscribeErrorCode: String, CaseIterable, Codable { case unauthorized = "UNAUTHORIZED" - case updateFailed = "UPDATE_FAILED" - } -} - -extension Enums { - /// UpdateReminderErrorCode - enum UpdateReminderErrorCode: String, CaseIterable, Codable { case badRequest = "BAD_REQUEST" case notFound = "NOT_FOUND" - case unauthorized = "UNAUTHORIZED" + case alreadySubscribed = "ALREADY_SUBSCRIBED" } } extension Enums { - /// UpdateSharedCommentErrorCode - enum UpdateSharedCommentErrorCode: String, CaseIterable, Codable { - case notFound = "NOT_FOUND" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// UpdateUserErrorCode - enum UpdateUserErrorCode: String, CaseIterable, Codable { - case bioTooLong = "BIO_TOO_LONG" - - case emptyName = "EMPTY_NAME" - + /// AddPopularReadErrorCode + enum AddPopularReadErrorCode: String, CaseIterable, Codable { case unauthorized = "UNAUTHORIZED" - case userNotFound = "USER_NOT_FOUND" - } -} - -extension Enums { - /// UpdateUserProfileErrorCode - enum UpdateUserProfileErrorCode: String, CaseIterable, Codable { - case badData = "BAD_DATA" - - case badUsername = "BAD_USERNAME" - - case forbidden = "FORBIDDEN" - - case unauthorized = "UNAUTHORIZED" - - case usernameExists = "USERNAME_EXISTS" - } -} - -extension Enums { - /// UploadFileRequestErrorCode - enum UploadFileRequestErrorCode: String, CaseIterable, Codable { - case badInput = "BAD_INPUT" - - case failedCreate = "FAILED_CREATE" - - case unauthorized = "UNAUTHORIZED" - } -} - -extension Enums { - /// UploadFileStatus - enum UploadFileStatus: String, CaseIterable, Codable { - case completed = "COMPLETED" - - case initialized = "INITIALIZED" - } -} - -extension Enums { - /// UserErrorCode - enum UserErrorCode: String, CaseIterable, Codable { case badRequest = "BAD_REQUEST" - case unauthorized = "UNAUTHORIZED" - - case userNotFound = "USER_NOT_FOUND" - } -} - -extension Enums { - /// UsersErrorCode - enum UsersErrorCode: String, CaseIterable, Codable { - case unauthorized = "UNAUTHORIZED" + case notFound = "NOT_FOUND" } } @@ -20490,20 +20532,124 @@ extension Enums { enum InputObjects {} extension InputObjects { - struct ArchiveLinkInput: Encodable, Hashable { - var archived: Bool + struct SortParams: Encodable, Hashable { + var order: OptionalArgument = .absent() - var linkId: String + var by: Enums.SortBy func encode(to encoder: Encoder) throws { var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(archived, forKey: .archived) - try container.encode(linkId, forKey: .linkId) + if order.hasValue { try container.encode(order, forKey: .order) } + try container.encode(by, forKey: .by) } enum CodingKeys: String, CodingKey { - case archived - case linkId + case order + case by + } + } +} + +extension InputObjects { + struct GoogleLoginInput: Encodable, Hashable { + var secret: String + + var email: String + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(secret, forKey: .secret) + try container.encode(email, forKey: .email) + } + + enum CodingKeys: String, CodingKey { + case secret + case email + } + } +} + +extension InputObjects { + struct GoogleSignupInput: Encodable, Hashable { + var secret: String + + var email: String + + var username: String + + var name: String + + var pictureUrl: String + + var sourceUserId: String + + var bio: OptionalArgument = .absent() + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(secret, forKey: .secret) + try container.encode(email, forKey: .email) + try container.encode(username, forKey: .username) + try container.encode(name, forKey: .name) + try container.encode(pictureUrl, forKey: .pictureUrl) + try container.encode(sourceUserId, forKey: .sourceUserId) + if bio.hasValue { try container.encode(bio, forKey: .bio) } + } + + enum CodingKeys: String, CodingKey { + case secret + case email + case username + case name + case pictureUrl + case sourceUserId + case bio + } + } +} + +extension InputObjects { + struct UpdateUserInput: Encodable, Hashable { + var name: String + + var bio: OptionalArgument = .absent() + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(name, forKey: .name) + if bio.hasValue { try container.encode(bio, forKey: .bio) } + } + + enum CodingKeys: String, CodingKey { + case name + case bio + } + } +} + +extension InputObjects { + struct UpdateUserProfileInput: Encodable, Hashable { + var userId: String + + var username: OptionalArgument = .absent() + + var bio: OptionalArgument = .absent() + + var pictureUrl: OptionalArgument = .absent() + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(userId, forKey: .userId) + if username.hasValue { try container.encode(username, forKey: .username) } + if bio.hasValue { try container.encode(bio, forKey: .bio) } + if pictureUrl.hasValue { try container.encode(pictureUrl, forKey: .pictureUrl) } + } + + enum CodingKeys: String, CodingKey { + case userId + case username + case bio + case pictureUrl } } } @@ -20523,377 +20669,41 @@ extension InputObjects { } } -extension InputObjects { - struct CreateArticleInput: Encodable, Hashable { - var articleSavingRequestId: OptionalArgument = .absent() - - var preparedDocument: OptionalArgument = .absent() - - var skipParsing: OptionalArgument = .absent() - - var source: OptionalArgument = .absent() - - var uploadFileId: OptionalArgument = .absent() - - var url: String - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - if articleSavingRequestId.hasValue { try container.encode(articleSavingRequestId, forKey: .articleSavingRequestId) } - if preparedDocument.hasValue { try container.encode(preparedDocument, forKey: .preparedDocument) } - if skipParsing.hasValue { try container.encode(skipParsing, forKey: .skipParsing) } - if source.hasValue { try container.encode(source, forKey: .source) } - if uploadFileId.hasValue { try container.encode(uploadFileId, forKey: .uploadFileId) } - try container.encode(url, forKey: .url) - } - - enum CodingKeys: String, CodingKey { - case articleSavingRequestId - case preparedDocument - case skipParsing - case source - case uploadFileId - case url - } - } -} - -extension InputObjects { - struct CreateArticleSavingRequestInput: Encodable, Hashable { - var url: String - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(url, forKey: .url) - } - - enum CodingKeys: String, CodingKey { - case url - } - } -} - -extension InputObjects { - struct CreateHighlightInput: Encodable, Hashable { - var annotation: OptionalArgument = .absent() - - var articleId: String - - var id: String - - var patch: String - - var prefix: OptionalArgument = .absent() - - var quote: String - - var sharedAt: OptionalArgument = .absent() - - var shortId: String - - var suffix: OptionalArgument = .absent() - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - if annotation.hasValue { try container.encode(annotation, forKey: .annotation) } - try container.encode(articleId, forKey: .articleId) - try container.encode(id, forKey: .id) - try container.encode(patch, forKey: .patch) - if prefix.hasValue { try container.encode(prefix, forKey: .prefix) } - try container.encode(quote, forKey: .quote) - if sharedAt.hasValue { try container.encode(sharedAt, forKey: .sharedAt) } - try container.encode(shortId, forKey: .shortId) - if suffix.hasValue { try container.encode(suffix, forKey: .suffix) } - } - - enum CodingKeys: String, CodingKey { - case annotation - case articleId - case id - case patch - case prefix - case quote - case sharedAt - case shortId - case suffix - } - } -} - -extension InputObjects { - struct CreateHighlightReplyInput: Encodable, Hashable { - var highlightId: String - - var text: String - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(highlightId, forKey: .highlightId) - try container.encode(text, forKey: .text) - } - - enum CodingKeys: String, CodingKey { - case highlightId - case text - } - } -} - -extension InputObjects { - struct CreateLabelInput: Encodable, Hashable { - var color: String - - var description: OptionalArgument = .absent() - - var name: String - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(color, forKey: .color) - if description.hasValue { try container.encode(description, forKey: .description) } - try container.encode(name, forKey: .name) - } - - enum CodingKeys: String, CodingKey { - case color - case description - case name - } - } -} - -extension InputObjects { - struct CreateReactionInput: Encodable, Hashable { - var code: Enums.ReactionType - - var highlightId: OptionalArgument = .absent() - - var userArticleId: OptionalArgument = .absent() - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(code, forKey: .code) - if highlightId.hasValue { try container.encode(highlightId, forKey: .highlightId) } - if userArticleId.hasValue { try container.encode(userArticleId, forKey: .userArticleId) } - } - - enum CodingKeys: String, CodingKey { - case code - case highlightId - case userArticleId - } - } -} - -extension InputObjects { - struct CreateReminderInput: Encodable, Hashable { - var archiveUntil: Bool - - var clientRequestId: OptionalArgument = .absent() - - var linkId: OptionalArgument = .absent() - - var remindAt: DateTime - - var sendNotification: Bool - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(archiveUntil, forKey: .archiveUntil) - if clientRequestId.hasValue { try container.encode(clientRequestId, forKey: .clientRequestId) } - if linkId.hasValue { try container.encode(linkId, forKey: .linkId) } - try container.encode(remindAt, forKey: .remindAt) - try container.encode(sendNotification, forKey: .sendNotification) - } - - enum CodingKeys: String, CodingKey { - case archiveUntil - case clientRequestId - case linkId - case remindAt - case sendNotification - } - } -} - -extension InputObjects { - struct GenerateApiKeyInput: Encodable, Hashable { - var expiredAt: OptionalArgument = .absent() - - var scope: OptionalArgument = .absent() - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - if expiredAt.hasValue { try container.encode(expiredAt, forKey: .expiredAt) } - if scope.hasValue { try container.encode(scope, forKey: .scope) } - } - - enum CodingKeys: String, CodingKey { - case expiredAt - case scope - } - } -} - -extension InputObjects { - struct GoogleLoginInput: Encodable, Hashable { - var email: String - - var secret: String - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(email, forKey: .email) - try container.encode(secret, forKey: .secret) - } - - enum CodingKeys: String, CodingKey { - case email - case secret - } - } -} - -extension InputObjects { - struct GoogleSignupInput: Encodable, Hashable { - var bio: OptionalArgument = .absent() - - var email: String - - var name: String - - var pictureUrl: String - - var secret: String - - var sourceUserId: String - - var username: String - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - if bio.hasValue { try container.encode(bio, forKey: .bio) } - try container.encode(email, forKey: .email) - try container.encode(name, forKey: .name) - try container.encode(pictureUrl, forKey: .pictureUrl) - try container.encode(secret, forKey: .secret) - try container.encode(sourceUserId, forKey: .sourceUserId) - try container.encode(username, forKey: .username) - } - - enum CodingKeys: String, CodingKey { - case bio - case email - case name - case pictureUrl - case secret - case sourceUserId - case username - } - } -} - -extension InputObjects { - struct LoginInput: Encodable, Hashable { - var email: String - - var password: String - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(email, forKey: .email) - try container.encode(password, forKey: .password) - } - - enum CodingKeys: String, CodingKey { - case email - case password - } - } -} - -extension InputObjects { - struct MergeHighlightInput: Encodable, Hashable { - var annotation: OptionalArgument = .absent() - - var articleId: String - - var id: String - - var overlapHighlightIdList: [String] - - var patch: String - - var prefix: OptionalArgument = .absent() - - var quote: String - - var shortId: String - - var suffix: OptionalArgument = .absent() - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - if annotation.hasValue { try container.encode(annotation, forKey: .annotation) } - try container.encode(articleId, forKey: .articleId) - try container.encode(id, forKey: .id) - try container.encode(overlapHighlightIdList, forKey: .overlapHighlightIdList) - try container.encode(patch, forKey: .patch) - if prefix.hasValue { try container.encode(prefix, forKey: .prefix) } - try container.encode(quote, forKey: .quote) - try container.encode(shortId, forKey: .shortId) - if suffix.hasValue { try container.encode(suffix, forKey: .suffix) } - } - - enum CodingKeys: String, CodingKey { - case annotation - case articleId - case id - case overlapHighlightIdList - case patch - case prefix - case quote - case shortId - case suffix - } - } -} - extension InputObjects { struct PageInfoInput: Encodable, Hashable { + var title: OptionalArgument = .absent() + var author: OptionalArgument = .absent() - var canonicalUrl: OptionalArgument = .absent() - - var contentType: OptionalArgument = .absent() - var description: OptionalArgument = .absent() var previewImage: OptionalArgument = .absent() + var canonicalUrl: OptionalArgument = .absent() + var publishedAt: OptionalArgument = .absent() - var title: OptionalArgument = .absent() + var contentType: OptionalArgument = .absent() func encode(to encoder: Encoder) throws { var container = encoder.container(keyedBy: CodingKeys.self) + if title.hasValue { try container.encode(title, forKey: .title) } if author.hasValue { try container.encode(author, forKey: .author) } - if canonicalUrl.hasValue { try container.encode(canonicalUrl, forKey: .canonicalUrl) } - if contentType.hasValue { try container.encode(contentType, forKey: .contentType) } if description.hasValue { try container.encode(description, forKey: .description) } if previewImage.hasValue { try container.encode(previewImage, forKey: .previewImage) } + if canonicalUrl.hasValue { try container.encode(canonicalUrl, forKey: .canonicalUrl) } if publishedAt.hasValue { try container.encode(publishedAt, forKey: .publishedAt) } - if title.hasValue { try container.encode(title, forKey: .title) } + if contentType.hasValue { try container.encode(contentType, forKey: .contentType) } } enum CodingKeys: String, CodingKey { + case title case author - case canonicalUrl - case contentType case description case previewImage + case canonicalUrl case publishedAt - case title + case contentType } } } @@ -20918,32 +20728,186 @@ extension InputObjects { } extension InputObjects { - struct ReportItemInput: Encodable, Hashable { - var itemUrl: String + struct UploadFileRequestInput: Encodable, Hashable { + var url: String - var pageId: String + var contentType: String - var reportComment: String + var createPageEntry: OptionalArgument = .absent() - var reportTypes: [Enums.ReportType] - - var sharedBy: OptionalArgument = .absent() + var clientRequestId: OptionalArgument = .absent() func encode(to encoder: Encoder) throws { var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(itemUrl, forKey: .itemUrl) - try container.encode(pageId, forKey: .pageId) - try container.encode(reportComment, forKey: .reportComment) - try container.encode(reportTypes, forKey: .reportTypes) - if sharedBy.hasValue { try container.encode(sharedBy, forKey: .sharedBy) } + try container.encode(url, forKey: .url) + try container.encode(contentType, forKey: .contentType) + if createPageEntry.hasValue { try container.encode(createPageEntry, forKey: .createPageEntry) } + if clientRequestId.hasValue { try container.encode(clientRequestId, forKey: .clientRequestId) } + } + + enum CodingKeys: String, CodingKey { + case url + case contentType + case createPageEntry + case clientRequestId + } + } +} + +extension InputObjects { + struct CreateArticleInput: Encodable, Hashable { + var url: String + + var preparedDocument: OptionalArgument = .absent() + + var articleSavingRequestId: OptionalArgument = .absent() + + var uploadFileId: OptionalArgument = .absent() + + var skipParsing: OptionalArgument = .absent() + + var source: OptionalArgument = .absent() + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(url, forKey: .url) + if preparedDocument.hasValue { try container.encode(preparedDocument, forKey: .preparedDocument) } + if articleSavingRequestId.hasValue { try container.encode(articleSavingRequestId, forKey: .articleSavingRequestId) } + if uploadFileId.hasValue { try container.encode(uploadFileId, forKey: .uploadFileId) } + if skipParsing.hasValue { try container.encode(skipParsing, forKey: .skipParsing) } + if source.hasValue { try container.encode(source, forKey: .source) } + } + + enum CodingKeys: String, CodingKey { + case url + case preparedDocument + case articleSavingRequestId + case uploadFileId + case skipParsing + case source + } + } +} + +extension InputObjects { + struct SaveFileInput: Encodable, Hashable { + var url: String + + var source: String + + var clientRequestId: String + + var uploadFileId: String + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(url, forKey: .url) + try container.encode(source, forKey: .source) + try container.encode(clientRequestId, forKey: .clientRequestId) + try container.encode(uploadFileId, forKey: .uploadFileId) + } + + enum CodingKeys: String, CodingKey { + case url + case source + case clientRequestId + case uploadFileId + } + } +} + +extension InputObjects { + struct SavePageInput: Encodable, Hashable { + var url: String + + var source: String + + var clientRequestId: String + + var title: OptionalArgument = .absent() + + var originalContent: String + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(url, forKey: .url) + try container.encode(source, forKey: .source) + try container.encode(clientRequestId, forKey: .clientRequestId) + if title.hasValue { try container.encode(title, forKey: .title) } + try container.encode(originalContent, forKey: .originalContent) + } + + enum CodingKeys: String, CodingKey { + case url + case source + case clientRequestId + case title + case originalContent + } + } +} + +extension InputObjects { + struct SaveUrlInput: Encodable, Hashable { + var url: String + + var source: String + + var clientRequestId: String + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(url, forKey: .url) + try container.encode(source, forKey: .source) + try container.encode(clientRequestId, forKey: .clientRequestId) + } + + enum CodingKeys: String, CodingKey { + case url + case source + case clientRequestId + } + } +} + +extension InputObjects { + struct UpdatePageInput: Encodable, Hashable { + var pageId: String + + var title: OptionalArgument = .absent() + + var description: OptionalArgument = .absent() + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(pageId, forKey: .pageId) + if title.hasValue { try container.encode(title, forKey: .title) } + if description.hasValue { try container.encode(description, forKey: .description) } } enum CodingKeys: String, CodingKey { - case itemUrl case pageId - case reportComment - case reportTypes - case sharedBy + case title + case description + } + } +} + +extension InputObjects { + struct SetFollowInput: Encodable, Hashable { + var userId: String + + var follow: Bool + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(userId, forKey: .userId) + try container.encode(follow, forKey: .follow) + } + + enum CodingKeys: String, CodingKey { + case userId + case follow } } } @@ -20952,102 +20916,21 @@ extension InputObjects { struct SaveArticleReadingProgressInput: Encodable, Hashable { var id: String - var readingProgressAnchorIndex: Int - var readingProgressPercent: Double + var readingProgressAnchorIndex: Int + func encode(to encoder: Encoder) throws { var container = encoder.container(keyedBy: CodingKeys.self) try container.encode(id, forKey: .id) - try container.encode(readingProgressAnchorIndex, forKey: .readingProgressAnchorIndex) try container.encode(readingProgressPercent, forKey: .readingProgressPercent) + try container.encode(readingProgressAnchorIndex, forKey: .readingProgressAnchorIndex) } enum CodingKeys: String, CodingKey { case id - case readingProgressAnchorIndex case readingProgressPercent - } - } -} - -extension InputObjects { - struct SaveFileInput: Encodable, Hashable { - var clientRequestId: String - - var source: String - - var uploadFileId: String - - var url: String - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(clientRequestId, forKey: .clientRequestId) - try container.encode(source, forKey: .source) - try container.encode(uploadFileId, forKey: .uploadFileId) - try container.encode(url, forKey: .url) - } - - enum CodingKeys: String, CodingKey { - case clientRequestId - case source - case uploadFileId - case url - } - } -} - -extension InputObjects { - struct SavePageInput: Encodable, Hashable { - var clientRequestId: String - - var originalContent: String - - var source: String - - var title: OptionalArgument = .absent() - - var url: String - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(clientRequestId, forKey: .clientRequestId) - try container.encode(originalContent, forKey: .originalContent) - try container.encode(source, forKey: .source) - if title.hasValue { try container.encode(title, forKey: .title) } - try container.encode(url, forKey: .url) - } - - enum CodingKeys: String, CodingKey { - case clientRequestId - case originalContent - case source - case title - case url - } - } -} - -extension InputObjects { - struct SaveUrlInput: Encodable, Hashable { - var clientRequestId: String - - var source: String - - var url: String - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(clientRequestId, forKey: .clientRequestId) - try container.encode(source, forKey: .source) - try container.encode(url, forKey: .url) - } - - enum CodingKeys: String, CodingKey { - case clientRequestId - case source - case url + case readingProgressAnchorIndex } } } @@ -21072,58 +20955,179 @@ extension InputObjects { } extension InputObjects { - struct SetDeviceTokenInput: Encodable, Hashable { - var id: OptionalArgument = .absent() + struct CreateHighlightInput: Encodable, Hashable { + var id: String - var token: OptionalArgument = .absent() + var shortId: String + + var articleId: String + + var patch: String + + var quote: String + + var prefix: OptionalArgument = .absent() + + var suffix: OptionalArgument = .absent() + + var annotation: OptionalArgument = .absent() + + var sharedAt: OptionalArgument = .absent() func encode(to encoder: Encoder) throws { var container = encoder.container(keyedBy: CodingKeys.self) - if id.hasValue { try container.encode(id, forKey: .id) } - if token.hasValue { try container.encode(token, forKey: .token) } + try container.encode(id, forKey: .id) + try container.encode(shortId, forKey: .shortId) + try container.encode(articleId, forKey: .articleId) + try container.encode(patch, forKey: .patch) + try container.encode(quote, forKey: .quote) + if prefix.hasValue { try container.encode(prefix, forKey: .prefix) } + if suffix.hasValue { try container.encode(suffix, forKey: .suffix) } + if annotation.hasValue { try container.encode(annotation, forKey: .annotation) } + if sharedAt.hasValue { try container.encode(sharedAt, forKey: .sharedAt) } } enum CodingKeys: String, CodingKey { case id - case token + case shortId + case articleId + case patch + case quote + case prefix + case suffix + case annotation + case sharedAt } } } extension InputObjects { - struct SetFollowInput: Encodable, Hashable { - var follow: Bool + struct MergeHighlightInput: Encodable, Hashable { + var id: String - var userId: String + var shortId: String + + var articleId: String + + var patch: String + + var quote: String + + var prefix: OptionalArgument = .absent() + + var suffix: OptionalArgument = .absent() + + var annotation: OptionalArgument = .absent() + + var overlapHighlightIdList: [String] func encode(to encoder: Encoder) throws { var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(follow, forKey: .follow) - try container.encode(userId, forKey: .userId) + try container.encode(id, forKey: .id) + try container.encode(shortId, forKey: .shortId) + try container.encode(articleId, forKey: .articleId) + try container.encode(patch, forKey: .patch) + try container.encode(quote, forKey: .quote) + if prefix.hasValue { try container.encode(prefix, forKey: .prefix) } + if suffix.hasValue { try container.encode(suffix, forKey: .suffix) } + if annotation.hasValue { try container.encode(annotation, forKey: .annotation) } + try container.encode(overlapHighlightIdList, forKey: .overlapHighlightIdList) } enum CodingKeys: String, CodingKey { - case follow - case userId + case id + case shortId + case articleId + case patch + case quote + case prefix + case suffix + case annotation + case overlapHighlightIdList } } } extension InputObjects { - struct SetLabelsInput: Encodable, Hashable { - var labelIds: [String] + struct UpdateHighlightInput: Encodable, Hashable { + var highlightId: String - var pageId: String + var annotation: OptionalArgument = .absent() + + var sharedAt: OptionalArgument = .absent() func encode(to encoder: Encoder) throws { var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(labelIds, forKey: .labelIds) - try container.encode(pageId, forKey: .pageId) + try container.encode(highlightId, forKey: .highlightId) + if annotation.hasValue { try container.encode(annotation, forKey: .annotation) } + if sharedAt.hasValue { try container.encode(sharedAt, forKey: .sharedAt) } } enum CodingKeys: String, CodingKey { - case labelIds - case pageId + case highlightId + case annotation + case sharedAt + } + } +} + +extension InputObjects { + struct CreateHighlightReplyInput: Encodable, Hashable { + var highlightId: String + + var text: String + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(highlightId, forKey: .highlightId) + try container.encode(text, forKey: .text) + } + + enum CodingKeys: String, CodingKey { + case highlightId + case text + } + } +} + +extension InputObjects { + struct UpdateHighlightReplyInput: Encodable, Hashable { + var highlightReplyId: String + + var text: String + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(highlightReplyId, forKey: .highlightReplyId) + try container.encode(text, forKey: .text) + } + + enum CodingKeys: String, CodingKey { + case highlightReplyId + case text + } + } +} + +extension InputObjects { + struct CreateReactionInput: Encodable, Hashable { + var highlightId: OptionalArgument = .absent() + + var userArticleId: OptionalArgument = .absent() + + var code: Enums.ReactionType + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + if highlightId.hasValue { try container.encode(highlightId, forKey: .highlightId) } + if userArticleId.hasValue { try container.encode(userArticleId, forKey: .userArticleId) } + try container.encode(code, forKey: .code) + } + + enum CodingKeys: String, CodingKey { + case highlightId + case userArticleId + case code } } } @@ -21155,256 +21159,6 @@ extension InputObjects { } } -extension InputObjects { - struct SetShareHighlightInput: Encodable, Hashable { - var id: String - - var share: Bool - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(id, forKey: .id) - try container.encode(share, forKey: .share) - } - - enum CodingKeys: String, CodingKey { - case id - case share - } - } -} - -extension InputObjects { - struct SetUserPersonalizationInput: Encodable, Hashable { - var fontFamily: OptionalArgument = .absent() - - var fontSize: OptionalArgument = .absent() - - var libraryLayoutType: OptionalArgument = .absent() - - var librarySortOrder: OptionalArgument = .absent() - - var margin: OptionalArgument = .absent() - - var theme: OptionalArgument = .absent() - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - if fontFamily.hasValue { try container.encode(fontFamily, forKey: .fontFamily) } - if fontSize.hasValue { try container.encode(fontSize, forKey: .fontSize) } - if libraryLayoutType.hasValue { try container.encode(libraryLayoutType, forKey: .libraryLayoutType) } - if librarySortOrder.hasValue { try container.encode(librarySortOrder, forKey: .librarySortOrder) } - if margin.hasValue { try container.encode(margin, forKey: .margin) } - if theme.hasValue { try container.encode(theme, forKey: .theme) } - } - - enum CodingKeys: String, CodingKey { - case fontFamily - case fontSize - case libraryLayoutType - case librarySortOrder - case margin - case theme - } - } -} - -extension InputObjects { - struct SignupInput: Encodable, Hashable { - var bio: OptionalArgument = .absent() - - var email: String - - var name: String - - var password: String - - var pictureUrl: OptionalArgument = .absent() - - var username: String - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - if bio.hasValue { try container.encode(bio, forKey: .bio) } - try container.encode(email, forKey: .email) - try container.encode(name, forKey: .name) - try container.encode(password, forKey: .password) - if pictureUrl.hasValue { try container.encode(pictureUrl, forKey: .pictureUrl) } - try container.encode(username, forKey: .username) - } - - enum CodingKeys: String, CodingKey { - case bio - case email - case name - case password - case pictureUrl - case username - } - } -} - -extension InputObjects { - struct SortParams: Encodable, Hashable { - var by: Enums.SortBy - - var order: OptionalArgument = .absent() - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(by, forKey: .by) - if order.hasValue { try container.encode(order, forKey: .order) } - } - - enum CodingKeys: String, CodingKey { - case by - case order - } - } -} - -extension InputObjects { - struct UpdateHighlightInput: Encodable, Hashable { - var annotation: OptionalArgument = .absent() - - var highlightId: String - - var sharedAt: OptionalArgument = .absent() - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - if annotation.hasValue { try container.encode(annotation, forKey: .annotation) } - try container.encode(highlightId, forKey: .highlightId) - if sharedAt.hasValue { try container.encode(sharedAt, forKey: .sharedAt) } - } - - enum CodingKeys: String, CodingKey { - case annotation - case highlightId - case sharedAt - } - } -} - -extension InputObjects { - struct UpdateHighlightReplyInput: Encodable, Hashable { - var highlightReplyId: String - - var text: String - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(highlightReplyId, forKey: .highlightReplyId) - try container.encode(text, forKey: .text) - } - - enum CodingKeys: String, CodingKey { - case highlightReplyId - case text - } - } -} - -extension InputObjects { - struct UpdateLabelInput: Encodable, Hashable { - var color: String - - var description: OptionalArgument = .absent() - - var labelId: String - - var name: String - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(color, forKey: .color) - if description.hasValue { try container.encode(description, forKey: .description) } - try container.encode(labelId, forKey: .labelId) - try container.encode(name, forKey: .name) - } - - enum CodingKeys: String, CodingKey { - case color - case description - case labelId - case name - } - } -} - -extension InputObjects { - struct UpdateLinkShareInfoInput: Encodable, Hashable { - var description: String - - var linkId: String - - var title: String - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(description, forKey: .description) - try container.encode(linkId, forKey: .linkId) - try container.encode(title, forKey: .title) - } - - enum CodingKeys: String, CodingKey { - case description - case linkId - case title - } - } -} - -extension InputObjects { - struct UpdatePageInput: Encodable, Hashable { - var description: OptionalArgument = .absent() - - var pageId: String - - var title: OptionalArgument = .absent() - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - if description.hasValue { try container.encode(description, forKey: .description) } - try container.encode(pageId, forKey: .pageId) - if title.hasValue { try container.encode(title, forKey: .title) } - } - - enum CodingKeys: String, CodingKey { - case description - case pageId - case title - } - } -} - -extension InputObjects { - struct UpdateReminderInput: Encodable, Hashable { - var archiveUntil: Bool - - var id: String - - var remindAt: DateTime - - var sendNotification: Bool - - func encode(to encoder: Encoder) throws { - var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(archiveUntil, forKey: .archiveUntil) - try container.encode(id, forKey: .id) - try container.encode(remindAt, forKey: .remindAt) - try container.encode(sendNotification, forKey: .sendNotification) - } - - enum CodingKeys: String, CodingKey { - case archiveUntil - case id - case remindAt - case sendNotification - } - } -} - extension InputObjects { struct UpdateSharedCommentInput: Encodable, Hashable { var articleId: String @@ -21425,66 +21179,362 @@ extension InputObjects { } extension InputObjects { - struct UpdateUserInput: Encodable, Hashable { - var bio: OptionalArgument = .absent() + struct SetUserPersonalizationInput: Encodable, Hashable { + var theme: OptionalArgument = .absent() + + var fontSize: OptionalArgument = .absent() + + var fontFamily: OptionalArgument = .absent() + + var margin: OptionalArgument = .absent() + + var libraryLayoutType: OptionalArgument = .absent() + + var librarySortOrder: OptionalArgument = .absent() + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + if theme.hasValue { try container.encode(theme, forKey: .theme) } + if fontSize.hasValue { try container.encode(fontSize, forKey: .fontSize) } + if fontFamily.hasValue { try container.encode(fontFamily, forKey: .fontFamily) } + if margin.hasValue { try container.encode(margin, forKey: .margin) } + if libraryLayoutType.hasValue { try container.encode(libraryLayoutType, forKey: .libraryLayoutType) } + if librarySortOrder.hasValue { try container.encode(librarySortOrder, forKey: .librarySortOrder) } + } + + enum CodingKeys: String, CodingKey { + case theme + case fontSize + case fontFamily + case margin + case libraryLayoutType + case librarySortOrder + } + } +} + +extension InputObjects { + struct CreateArticleSavingRequestInput: Encodable, Hashable { + var url: String + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(url, forKey: .url) + } + + enum CodingKeys: String, CodingKey { + case url + } + } +} + +extension InputObjects { + struct SetShareHighlightInput: Encodable, Hashable { + var id: String + + var share: Bool + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(id, forKey: .id) + try container.encode(share, forKey: .share) + } + + enum CodingKeys: String, CodingKey { + case id + case share + } + } +} + +extension InputObjects { + struct ReportItemInput: Encodable, Hashable { + var pageId: String + + var itemUrl: String + + var sharedBy: OptionalArgument = .absent() + + var reportTypes: [Enums.ReportType] + + var reportComment: String + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(pageId, forKey: .pageId) + try container.encode(itemUrl, forKey: .itemUrl) + if sharedBy.hasValue { try container.encode(sharedBy, forKey: .sharedBy) } + try container.encode(reportTypes, forKey: .reportTypes) + try container.encode(reportComment, forKey: .reportComment) + } + + enum CodingKeys: String, CodingKey { + case pageId + case itemUrl + case sharedBy + case reportTypes + case reportComment + } + } +} + +extension InputObjects { + struct UpdateLinkShareInfoInput: Encodable, Hashable { + var linkId: String + + var title: String + + var description: String + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(linkId, forKey: .linkId) + try container.encode(title, forKey: .title) + try container.encode(description, forKey: .description) + } + + enum CodingKeys: String, CodingKey { + case linkId + case title + case description + } + } +} + +extension InputObjects { + struct ArchiveLinkInput: Encodable, Hashable { + var linkId: String + + var archived: Bool + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(linkId, forKey: .linkId) + try container.encode(archived, forKey: .archived) + } + + enum CodingKeys: String, CodingKey { + case linkId + case archived + } + } +} + +extension InputObjects { + struct CreateReminderInput: Encodable, Hashable { + var linkId: OptionalArgument = .absent() + + var clientRequestId: OptionalArgument = .absent() + + var archiveUntil: Bool + + var sendNotification: Bool + + var remindAt: DateTime + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + if linkId.hasValue { try container.encode(linkId, forKey: .linkId) } + if clientRequestId.hasValue { try container.encode(clientRequestId, forKey: .clientRequestId) } + try container.encode(archiveUntil, forKey: .archiveUntil) + try container.encode(sendNotification, forKey: .sendNotification) + try container.encode(remindAt, forKey: .remindAt) + } + + enum CodingKeys: String, CodingKey { + case linkId + case clientRequestId + case archiveUntil + case sendNotification + case remindAt + } + } +} + +extension InputObjects { + struct UpdateReminderInput: Encodable, Hashable { + var id: String + + var archiveUntil: Bool + + var sendNotification: Bool + + var remindAt: DateTime + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(id, forKey: .id) + try container.encode(archiveUntil, forKey: .archiveUntil) + try container.encode(sendNotification, forKey: .sendNotification) + try container.encode(remindAt, forKey: .remindAt) + } + + enum CodingKeys: String, CodingKey { + case id + case archiveUntil + case sendNotification + case remindAt + } + } +} + +extension InputObjects { + struct SetDeviceTokenInput: Encodable, Hashable { + var id: OptionalArgument = .absent() + + var token: OptionalArgument = .absent() + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + if id.hasValue { try container.encode(id, forKey: .id) } + if token.hasValue { try container.encode(token, forKey: .token) } + } + + enum CodingKeys: String, CodingKey { + case id + case token + } + } +} + +extension InputObjects { + struct CreateLabelInput: Encodable, Hashable { + var name: String + + var color: String + + var description: OptionalArgument = .absent() + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(name, forKey: .name) + try container.encode(color, forKey: .color) + if description.hasValue { try container.encode(description, forKey: .description) } + } + + enum CodingKeys: String, CodingKey { + case name + case color + case description + } + } +} + +extension InputObjects { + struct UpdateLabelInput: Encodable, Hashable { + var labelId: String + + var color: String + + var description: OptionalArgument = .absent() var name: String func encode(to encoder: Encoder) throws { var container = encoder.container(keyedBy: CodingKeys.self) - if bio.hasValue { try container.encode(bio, forKey: .bio) } + try container.encode(labelId, forKey: .labelId) + try container.encode(color, forKey: .color) + if description.hasValue { try container.encode(description, forKey: .description) } try container.encode(name, forKey: .name) } enum CodingKeys: String, CodingKey { - case bio + case labelId + case color + case description case name } } } extension InputObjects { - struct UpdateUserProfileInput: Encodable, Hashable { - var bio: OptionalArgument = .absent() + struct LoginInput: Encodable, Hashable { + var password: String - var pictureUrl: OptionalArgument = .absent() - - var userId: String - - var username: OptionalArgument = .absent() + var email: String func encode(to encoder: Encoder) throws { var container = encoder.container(keyedBy: CodingKeys.self) - if bio.hasValue { try container.encode(bio, forKey: .bio) } - if pictureUrl.hasValue { try container.encode(pictureUrl, forKey: .pictureUrl) } - try container.encode(userId, forKey: .userId) - if username.hasValue { try container.encode(username, forKey: .username) } + try container.encode(password, forKey: .password) + try container.encode(email, forKey: .email) } enum CodingKeys: String, CodingKey { - case bio - case pictureUrl - case userId - case username + case password + case email } } } extension InputObjects { - struct UploadFileRequestInput: Encodable, Hashable { - var contentType: String + struct SignupInput: Encodable, Hashable { + var email: String - var url: String + var password: String + + var username: String + + var name: String + + var pictureUrl: OptionalArgument = .absent() + + var bio: OptionalArgument = .absent() func encode(to encoder: Encoder) throws { var container = encoder.container(keyedBy: CodingKeys.self) - try container.encode(contentType, forKey: .contentType) - try container.encode(url, forKey: .url) + try container.encode(email, forKey: .email) + try container.encode(password, forKey: .password) + try container.encode(username, forKey: .username) + try container.encode(name, forKey: .name) + if pictureUrl.hasValue { try container.encode(pictureUrl, forKey: .pictureUrl) } + if bio.hasValue { try container.encode(bio, forKey: .bio) } } enum CodingKeys: String, CodingKey { - case contentType - case url + case email + case password + case username + case name + case pictureUrl + case bio + } + } +} + +extension InputObjects { + struct SetLabelsInput: Encodable, Hashable { + var pageId: String + + var labelIds: [String] + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(pageId, forKey: .pageId) + try container.encode(labelIds, forKey: .labelIds) + } + + enum CodingKeys: String, CodingKey { + case pageId + case labelIds + } + } +} + +extension InputObjects { + struct GenerateApiKeyInput: Encodable, Hashable { + var scope: OptionalArgument = .absent() + + var expiredAt: OptionalArgument = .absent() + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + if scope.hasValue { try container.encode(scope, forKey: .scope) } + if expiredAt.hasValue { try container.encode(expiredAt, forKey: .expiredAt) } + } + + enum CodingKeys: String, CodingKey { + case scope + case expiredAt } } } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/ArchiveLink.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/ArchiveLink.swift index d8412c8a9..2781b7a48 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/ArchiveLink.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/ArchiveLink.swift @@ -24,16 +24,16 @@ extension DataService { let selection = Selection { try $0.on( - archiveLinkError: .init { .error(errorCode: try $0.errorCodes().first ?? .badRequest) }, - archiveLinkSuccess: .init { .success(linkId: try $0.linkId()) } + archiveLinkSuccess: .init { .success(linkId: try $0.linkId()) }, + archiveLinkError: .init { .error(errorCode: try $0.errorCodes().first ?? .badRequest) } ) } let mutation = Selection.Mutation { try $0.setLinkArchived( input: InputObjects.ArchiveLinkInput( - archived: archived, - linkId: itemID + linkId: itemID, + archived: archived ), selection: selection ) diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateHighlight.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateHighlight.swift index 5cd1ad36d..9a8203ce0 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateHighlight.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateHighlight.swift @@ -40,22 +40,22 @@ extension DataService { let selection = Selection { try $0.on( - createHighlightError: .init { .error(errorCode: try $0.errorCodes().first ?? .badData) }, createHighlightSuccess: .init { .saved(highlight: try $0.highlight(selection: highlightSelection)) - } + }, + createHighlightError: .init { .error(errorCode: try $0.errorCodes().first ?? .badData) } ) } let mutation = Selection.Mutation { try $0.createHighlight( input: InputObjects.CreateHighlightInput( - annotation: OptionalArgument(highlight.annotation), - articleId: articleId, id: highlight.id, + shortId: highlight.shortId, + articleId: articleId, patch: highlight.patch, quote: highlight.quote, - shortId: highlight.shortId + annotation: OptionalArgument(highlight.annotation) ), selection: selection ) diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateLabelPublisher.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateLabelPublisher.swift index 8df8b0d4a..27e5785d0 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateLabelPublisher.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateLabelPublisher.swift @@ -34,17 +34,17 @@ extension DataService { let selection = Selection { try $0.on( - createLabelError: .init { .error(errorCode: try $0.errorCodes().first ?? .badRequest) }, - createLabelSuccess: .init { .saved(label: try $0.label(selection: feedItemLabelSelection)) } + createLabelSuccess: .init { .saved(label: try $0.label(selection: feedItemLabelSelection)) }, + createLabelError: .init { .error(errorCode: try $0.errorCodes().first ?? .badRequest) } ) } let mutation = Selection.Mutation { try $0.createLabel( input: InputObjects.CreateLabelInput( + name: label.name, color: label.color, - description: OptionalArgument(label.labelDescription), - name: label.name + description: OptionalArgument(label.labelDescription) ), selection: selection ) diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateNewsletterEmailMutation.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateNewsletterEmailMutation.swift index f65f5400f..d4ca80be5 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateNewsletterEmailMutation.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateNewsletterEmailMutation.swift @@ -12,9 +12,6 @@ public extension DataService { let selection = Selection { try $0.on( - createNewsletterEmailError: .init { - .error(errorCode: try $0.errorCodes().first ?? .badRequest) - }, createNewsletterEmailSuccess: .init { .saved(newsletterEmail: try $0.newsletterEmail(selection: Selection.NewsletterEmail { InternalNewsletterEmail( @@ -23,6 +20,9 @@ public extension DataService { confirmationCode: try $0.confirmationCode() ) })) + }, + createNewsletterEmailError: .init { + .error(errorCode: try $0.errorCodes().first ?? .badRequest) } ) } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateReminder.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateReminder.swift index f7ad4d475..6277dd9be 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateReminder.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/CreateReminder.swift @@ -37,21 +37,21 @@ public extension DataService { let selection = Selection { try $0.on( - createReminderError: .init { .error(errorCode: try $0.errorCodes().first ?? .badRequest) }, createReminderSuccess: .init { .complete(id: try $0.reminder(selection: Selection.Reminder { try $0.id() })) - } + }, + createReminderError: .init { .error(errorCode: try $0.errorCodes().first ?? .badRequest) } ) } let mutation = Selection.Mutation { try $0.createReminder( input: InputObjects.CreateReminderInput( - archiveUntil: true, - clientRequestId: OptionalArgument(reminderItemId.clientRequestId), linkId: OptionalArgument(reminderItemId.linkId), - remindAt: DateTime(from: remindAt), - sendNotification: true + clientRequestId: OptionalArgument(reminderItemId.clientRequestId), + archiveUntil: true, + sendNotification: true, + remindAt: DateTime(from: remindAt) ), selection: selection ) diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/DeleteHighlight.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/DeleteHighlight.swift index ff9a95b87..92f657946 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/DeleteHighlight.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/DeleteHighlight.swift @@ -30,10 +30,10 @@ public extension DataService { let selection = Selection { try $0.on( - deleteHighlightError: .init { .error(errorCode: try $0.errorCodes().first ?? .unauthorized) }, deleteHighlightSuccess: .init { .saved(id: try $0.highlight(selection: Selection.Highlight { try $0.id() })) - } + }, + deleteHighlightError: .init { .error(errorCode: try $0.errorCodes().first ?? .unauthorized) } ) } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/DeleteSubscription.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/DeleteSubscription.swift index d8bdf3289..05dbed3f2 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/DeleteSubscription.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/DeleteSubscription.swift @@ -12,8 +12,8 @@ public extension DataService { let selection = Selection { try $0.on( - unsubscribeError: .init { .error(errorMessage: (try $0.errorCodes().first ?? .unauthorized).rawValue) }, - unsubscribeSuccess: .init { .success(id: try $0.subscription(selection: Selection.Subscription { try $0.id() })) } + unsubscribeSuccess: .init { .success(id: try $0.subscription(selection: Selection.Subscription { try $0.id() })) }, + unsubscribeError: .init { .error(errorMessage: (try $0.errorCodes().first ?? .unauthorized).rawValue) } ) } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/DeviceToken.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/DeviceToken.swift index ec5692bdd..50c4485f0 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/DeviceToken.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/DeviceToken.swift @@ -34,10 +34,10 @@ public extension DataService { let selection = Selection { try $0.on( - setDeviceTokenError: .init { .error(errorCode: try $0.errorCodes().first ?? .badRequest) }, setDeviceTokenSuccess: .init { .saved(id: try $0.deviceToken(selection: Selection.DeviceToken { try $0.id() })) - } + }, + setDeviceTokenError: .init { .error(errorCode: try $0.errorCodes().first ?? .badRequest) } ) } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/MergeHighlight.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/MergeHighlight.swift index 4f8eefc3f..5b3c9d5f8 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/MergeHighlight.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/MergeHighlight.swift @@ -46,25 +46,25 @@ extension DataService { let selection = Selection { try $0.on( - mergeHighlightError: .init { .error(errorCode: try $0.errorCodes().first ?? .badData) }, mergeHighlightSuccess: .init { .saved(highlight: try $0.highlight(selection: highlightSelection)) - } + }, + mergeHighlightError: .init { .error(errorCode: try $0.errorCodes().first ?? .badData) } ) } let mutation = Selection.Mutation { try $0.mergeHighlight( input: InputObjects.MergeHighlightInput( - annotation: .absent(), - articleId: articleId, id: highlight.id, - overlapHighlightIdList: overlapHighlightIdList, - patch: highlight.patch, - prefix: .absent(), - quote: highlight.quote, shortId: highlight.shortId, - suffix: .absent() + articleId: articleId, + patch: highlight.patch, + quote: highlight.quote, + prefix: .absent(), + suffix: .absent(), + annotation: .absent(), + overlapHighlightIdList: overlapHighlightIdList ), selection: selection ) diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/RemoveLabelPublisher.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/RemoveLabelPublisher.swift index fc7c02c2b..0c10e85f8 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/RemoveLabelPublisher.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/RemoveLabelPublisher.swift @@ -23,10 +23,10 @@ extension DataService { let selection = Selection { try $0.on( - deleteLabelError: .init { .error(errorCode: try $0.errorCodes().first ?? .badRequest) }, deleteLabelSuccess: .init { .success(labelID: try $0.label(selection: Selection.Label { try $0.id() })) - } + }, + deleteLabelError: .init { .error(errorCode: try $0.errorCodes().first ?? .badRequest) } ) } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/RemoveLink.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/RemoveLink.swift index d6a3e3894..304b00449 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/RemoveLink.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/RemoveLink.swift @@ -24,14 +24,14 @@ extension DataService { let selection = Selection { try $0.on( - setBookmarkArticleError: .init { .error(errorCode: try $0.errorCodes().first ?? .notFound) }, setBookmarkArticleSuccess: .init { .success( linkId: try $0.bookmarkedArticle(selection: Selection.Article { try $0.id() }) ) - } + }, + setBookmarkArticleError: .init { .error(errorCode: try $0.errorCodes().first ?? .notFound) } ) } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SaveArticle.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SaveArticle.swift index cdb5a7a38..cc7352b41 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SaveArticle.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SaveArticle.swift @@ -29,7 +29,6 @@ public extension Networker { let selection = Selection { try $0.on( - articleSavingRequestError: .init { .error(errorCode: (try? $0.errorCodes().first) ?? .notFound) }, articleSavingRequestSuccess: .init { .saved( status: try $0.articleSavingRequest( @@ -41,7 +40,8 @@ public extension Networker { } ) ) - } + }, + articleSavingRequestError: .init { .error(errorCode: (try? $0.errorCodes().first) ?? .notFound) } ) } @@ -102,15 +102,15 @@ public extension DataService { }() let input = InputObjects.CreateArticleInput( + url: pageScrapePayload.url, preparedDocument: OptionalArgument(preparedDocument), - uploadFileId: uploadFileId != nil ? .present(uploadFileId!) : .null(), - url: pageScrapePayload.url + uploadFileId: uploadFileId != nil ? .present(uploadFileId!) : .null() ) let selection = Selection { try $0.on( - createArticleError: .init { .error(errorCode: (try? $0.errorCodes().first) ?? .unableToParse) }, - createArticleSuccess: .init { .saved(created: try $0.created()) } + createArticleSuccess: .init { .saved(created: try $0.created()) }, + createArticleError: .init { .error(errorCode: (try? $0.errorCodes().first) ?? .unableToParse) } ) } @@ -163,7 +163,6 @@ public extension DataService { let selection = Selection { try $0.on( - createArticleSavingRequestError: .init { .error(errorCode: (try? $0.errorCodes().first) ?? .badData) }, createArticleSavingRequestSuccess: .init { .saved( status: try $0.articleSavingRequest( @@ -175,7 +174,8 @@ public extension DataService { } ) ) - } + }, + createArticleSavingRequestError: .init { .error(errorCode: (try? $0.errorCodes().first) ?? .badData) } ) } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePDF.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePDF.swift index 058953ba1..4267b5a6f 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePDF.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePDF.swift @@ -9,7 +9,7 @@ public extension DataService { data: Data, requestId: String ) -> AnyPublisher { - uploadFileRequestPublisher(pageScrapePayload: pageScrapePayload) + uploadFileRequestPublisher(pageScrapePayload: pageScrapePayload, requestId: requestId) .flatMap { self.uploadFilePublisher(fileUploadConfig: $0, data: data) } .flatMap { self.saveFilePublisher(pageScrapePayload: pageScrapePayload, uploadFileId: $0, requestId: requestId) } .catch { _ in self.saveUrlPublisher(pageScrapePayload: pageScrapePayload, requestId: requestId) } @@ -26,20 +26,21 @@ private struct UploadFileRequestPayload { private extension DataService { // swiftlint:disable:next line_length - func uploadFileRequestPublisher(pageScrapePayload: PageScrapePayload) -> AnyPublisher { + func uploadFileRequestPublisher(pageScrapePayload: PageScrapePayload, requestId: String?) -> AnyPublisher { enum MutationResult { case success(payload: UploadFileRequestPayload) case error(errorCode: Enums.UploadFileRequestErrorCode?) } let input = InputObjects.UploadFileRequestInput( + url: pageScrapePayload.url, contentType: "application/pdf", - url: pageScrapePayload.url + createPageEntry: OptionalArgument(true), + clientRequestId: OptionalArgument(requestId) ) let selection = Selection { try $0.on( - uploadFileRequestError: .init { .error(errorCode: try? $0.errorCodes().first) }, uploadFileRequestSuccess: .init { .success( payload: UploadFileRequestPayload( @@ -48,7 +49,8 @@ private extension DataService { urlString: try $0.uploadSignedUrl() ) ) - } + }, + uploadFileRequestError: .init { .error(errorCode: try? $0.errorCodes().first) } ) } @@ -90,15 +92,13 @@ private extension DataService { // swiftlint:disable:next line_length func uploadFilePublisher(fileUploadConfig: UploadFileRequestPayload, data: Data) -> AnyPublisher { - let pdfData = data // URL(string: "http://localhost:4000/local/debug/endpoint").flatMap { try? Data(contentsOf: $0) } - let url = fileUploadConfig.urlString.flatMap { URL(string: $0) } guard let url = url else { return Future { $0(.failure(.badData)) }.eraseToAnyPublisher() } var request = URLRequest(url: url) request.httpMethod = "PUT" request.addValue("application/pdf", forHTTPHeaderField: "content-type") - request.httpBody = pdfData + request.httpBody = data return networker.urlSession.dataTaskPublisher(for: request) .tryMap { data, response -> String in @@ -133,16 +133,16 @@ private extension DataService { } let input = InputObjects.SaveFileInput( - clientRequestId: requestId, + url: pageScrapePayload.url, source: "ios-file", - uploadFileId: uploadFileId, - url: pageScrapePayload.url + clientRequestId: requestId, + uploadFileId: uploadFileId ) let selection = Selection { try $0.on( - saveError: .init { .error(errorCode: (try? $0.errorCodes().first) ?? .unknown) }, - saveSuccess: .init { .saved(requestId: requestId, url: (try? $0.url()) ?? "") } + saveSuccess: .init { .saved(requestId: requestId, url: (try? $0.url()) ?? "") }, + saveError: .init { .error(errorCode: (try? $0.errorCodes().first) ?? .unknown) } ) } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePage.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePage.swift index 7a8ccad53..b3ae4fc12 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePage.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SavePage.swift @@ -12,17 +12,16 @@ public extension DataService { } let input = InputObjects.SavePageInput( - clientRequestId: requestId, - originalContent: html, - source: "ios-page", + url: requestId, + source: html, + clientRequestId: "ios-page", title: OptionalArgument(title), - url: pageScrapePayload.url + originalContent: pageScrapePayload.url ) let selection = Selection { try $0.on( - saveError: .init { .error(errorCode: (try? $0.errorCodes().first) ?? .unknown) }, - saveSuccess: .init { .saved(requestId: requestId, url: (try? $0.url()) ?? "") } + saveSuccess: .init { .saved(requestId: requestId, url: (try? $0.url()) ?? "") }, saveError: .init { .error(errorCode: (try? $0.errorCodes().first) ?? .unknown) } ) } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SaveUrl.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SaveUrl.swift index 84a48df2b..3a2ba77e7 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SaveUrl.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/SaveUrl.swift @@ -12,15 +12,15 @@ public extension DataService { } let input = InputObjects.SaveUrlInput( - clientRequestId: requestId, + url: pageScrapePayload.url, source: "ios-url", - url: pageScrapePayload.url + clientRequestId: requestId ) let selection = Selection { try $0.on( - saveError: .init { .error(errorCode: (try? $0.errorCodes().first) ?? .unknown) }, - saveSuccess: .init { .saved(requestId: requestId, url: (try? $0.url()) ?? "") } + saveSuccess: .init { .saved(requestId: requestId, url: (try? $0.url()) ?? "") }, + saveError: .init { .error(errorCode: (try? $0.errorCodes().first) ?? .unknown) } ) } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/UpdateArticleLabelsPublisher.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/UpdateArticleLabelsPublisher.swift index cab778898..0cf46dfac 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/UpdateArticleLabelsPublisher.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/UpdateArticleLabelsPublisher.swift @@ -32,16 +32,16 @@ extension DataService { let selection = Selection { try $0.on( - setLabelsError: .init { .error(errorCode: try $0.errorCodes().first ?? .badRequest) }, - setLabelsSuccess: .init { .saved(feedItem: try $0.labels(selection: feedItemLabelSelection.list)) } + setLabelsSuccess: .init { .saved(feedItem: try $0.labels(selection: feedItemLabelSelection.list)) }, + setLabelsError: .init { .error(errorCode: try $0.errorCodes().first ?? .badRequest) } ) } let mutation = Selection.Mutation { try $0.setLabels( input: InputObjects.SetLabelsInput( - labelIds: labelIDs, - pageId: itemID + pageId: itemID, + labelIds: labelIDs ), selection: selection ) diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/UpdateArticleReadingProgress.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/UpdateArticleReadingProgress.swift index 90a7bc752..95ba6f308 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/UpdateArticleReadingProgress.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/UpdateArticleReadingProgress.swift @@ -33,12 +33,12 @@ extension DataService { let selection = Selection { try $0.on( - saveArticleReadingProgressError: .init { .error(errorCode: try $0.errorCodes().first ?? .badData) }, saveArticleReadingProgressSuccess: .init { .saved( readingProgress: try $0.updatedArticle(selection: Selection.Article { try $0.readingProgressPercent() }) ) - } + }, + saveArticleReadingProgressError: .init { .error(errorCode: try $0.errorCodes().first ?? .badData) } ) } @@ -46,8 +46,8 @@ extension DataService { try $0.saveArticleReadingProgress( input: InputObjects.SaveArticleReadingProgressInput( id: itemID, - readingProgressAnchorIndex: anchorIndex, - readingProgressPercent: readingProgress + readingProgressPercent: readingProgress, + readingProgressAnchorIndex: anchorIndex ), selection: selection ) diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/UpdateHighlightAttributes.swift b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/UpdateHighlightAttributes.swift index ae757c230..781306f18 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Mutations/UpdateHighlightAttributes.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Mutations/UpdateHighlightAttributes.swift @@ -31,18 +31,18 @@ extension DataService { let selection = Selection { try $0.on( - updateHighlightError: .init { .error(errorCode: try $0.errorCodes().first ?? .badData) }, updateHighlightSuccess: .init { .saved(highlight: try $0.highlight(selection: highlightSelection)) - } + }, + updateHighlightError: .init { .error(errorCode: try $0.errorCodes().first ?? .badData) } ) } let mutation = Selection.Mutation { try $0.updateHighlight( input: InputObjects.UpdateHighlightInput( - annotation: OptionalArgument(annotation), highlightId: highlightID, + annotation: OptionalArgument(annotation), sharedAt: OptionalArgument(nil) ), selection: selection diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Queries/ArticleContentQuery.swift b/apple/OmnivoreKit/Sources/Services/DataService/Queries/ArticleContentQuery.swift index ebb8a3bf8..7fedac735 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Queries/ArticleContentQuery.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Queries/ArticleContentQuery.swift @@ -90,7 +90,7 @@ extension DataService { case error(error: String) } - let articleSelection = Selection.Article { + let articleContentSelection = Selection.Article { ArticleProps( item: InternalLinkedItem( id: try $0.id(), @@ -121,18 +121,17 @@ extension DataService { let selection = Selection { try $0.on( + articleSuccess: .init { + QueryResult.success(result: try $0.article(selection: articleContentSelection)) + }, articleError: .init { QueryResult.error(error: try $0.errorCodes().description) - }, - articleSuccess: .init { - QueryResult.success(result: try $0.article(selection: articleSelection)) } ) } let query = Selection.Query { - // backend has a hack that allows us to pass in itemID in place of slug - try $0.article(slug: itemID, username: username, selection: selection) + try $0.article(username: username, slug: itemID, selection: selection) } let path = appEnvironment.graphqlPath diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Queries/LabelsPublisher.swift b/apple/OmnivoreKit/Sources/Services/DataService/Queries/LabelsPublisher.swift index b6b920a25..9d8478d9f 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Queries/LabelsPublisher.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Queries/LabelsPublisher.swift @@ -12,11 +12,11 @@ public extension DataService { let selection = Selection { try $0.on( - labelsError: .init { - QueryResult.error(error: try $0.errorCodes().description) - }, labelsSuccess: .init { QueryResult.success(result: try $0.labels(selection: feedItemLabelSelection.list)) + }, + labelsError: .init { + QueryResult.error(error: try $0.errorCodes().description) } ) } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Queries/LibraryItemsQuery.swift b/apple/OmnivoreKit/Sources/Services/DataService/Queries/LibraryItemsQuery.swift index 286171204..edc905154 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Queries/LibraryItemsQuery.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Queries/LibraryItemsQuery.swift @@ -24,9 +24,6 @@ public extension DataService { let selection = Selection { try $0.on( - articlesError: .init { - QueryResult.error(error: try $0.errorCodes().description) - }, articlesSuccess: .init { QueryResult.success( result: InternalHomeFeedData( @@ -36,22 +33,25 @@ public extension DataService { }) ) ) + }, + articlesError: .init { + QueryResult.error(error: try $0.errorCodes().description) } ) } let query = Selection.Query { try $0.articles( - after: OptionalArgument(cursor), - first: OptionalArgument(limit), - includePending: OptionalArgument(true), - query: OptionalArgument(searchQuery), sharedOnly: .present(false), sort: OptionalArgument( InputObjects.SortParams( - by: .updatedTime, order: .present(.descending) + order: .present(.descending), by: .updatedTime ) ), + after: OptionalArgument(cursor), + first: OptionalArgument(limit), + query: OptionalArgument(searchQuery), + includePending: OptionalArgument(true), selection: selection ) } @@ -90,20 +90,44 @@ public extension DataService { case error(error: String) } + let articleSelection = Selection.Article { + InternalLinkedItem( + id: try $0.id(), + title: try $0.title(), + createdAt: try $0.createdAt().value ?? Date(), + savedAt: try $0.savedAt().value ?? Date(), + readingProgress: try $0.readingProgressPercent(), + readingProgressAnchor: try $0.readingProgressAnchorIndex(), + imageURLString: try $0.image(), + onDeviceImageURLString: nil, + documentDirectoryPath: nil, + pageURLString: try $0.url(), + descriptionText: try $0.description(), + publisherURLString: try $0.originalArticleUrl(), + siteName: try $0.siteName(), + author: try $0.author(), + publishDate: try $0.publishedAt()?.value, + slug: try $0.slug(), + isArchived: try $0.isArchived(), + contentReader: try $0.contentReader().rawValue, + labels: try $0.labels(selection: feedItemLabelSelection.list.nullable) ?? [] + ) + } + let selection = Selection { try $0.on( - articleError: .init { - QueryResult.error(error: try $0.errorCodes().description) - }, articleSuccess: .init { QueryResult.success(result: try $0.article(selection: articleSelection)) + }, + articleError: .init { + QueryResult.error(error: try $0.errorCodes().description) } ) } let query = Selection.Query { // backend has a hack that allows us to pass in itemID in place of slug - try $0.article(slug: itemID, username: username, selection: selection) + try $0.article(username: username, slug: itemID, selection: selection) } let path = appEnvironment.graphqlPath @@ -130,7 +154,7 @@ public extension DataService { } } -private let articleSelection = Selection.Article { +private let libraryArticleSelection = Selection.Article { InternalLinkedItem( id: try $0.id(), title: try $0.title(), @@ -155,5 +179,5 @@ private let articleSelection = Selection.Article { } private let articleEdgeSelection = Selection.ArticleEdge { - try $0.node(selection: articleSelection) + try $0.node(selection: libraryArticleSelection) } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Queries/LinkedItemIDsQuery.swift b/apple/OmnivoreKit/Sources/Services/DataService/Queries/LinkedItemIDsQuery.swift index f6dede0d3..1411cf1e8 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Queries/LinkedItemIDsQuery.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Queries/LinkedItemIDsQuery.swift @@ -20,9 +20,6 @@ extension DataService { let selection = Selection { try $0.on( - searchError: .init { - QueryResult.error(error: try $0.errorCodes().description) - }, searchSuccess: .init { QueryResult.success( result: LinkedItemIDFetchResult( @@ -32,6 +29,9 @@ extension DataService { }) ) ) + }, + searchError: .init { + QueryResult.error(error: try $0.errorCodes().description) } ) } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Queries/NewsletterEmailsQuery.swift b/apple/OmnivoreKit/Sources/Services/DataService/Queries/NewsletterEmailsQuery.swift index ff8e05bf2..49545956c 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Queries/NewsletterEmailsQuery.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Queries/NewsletterEmailsQuery.swift @@ -20,11 +20,11 @@ public extension DataService { let selection = Selection { try $0.on( - newsletterEmailsError: .init { - QueryResult.error(error: try $0.errorCodes().description) - }, newsletterEmailsSuccess: .init { QueryResult.success(result: try $0.newsletterEmails(selection: newsletterEmailSelection.list)) + }, + newsletterEmailsError: .init { + QueryResult.error(error: try $0.errorCodes().description) } ) } diff --git a/apple/OmnivoreKit/Sources/Services/DataService/Queries/SubscriptionsQuery.swift b/apple/OmnivoreKit/Sources/Services/DataService/Queries/SubscriptionsQuery.swift index 2c2976126..962e42de6 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/Queries/SubscriptionsQuery.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/Queries/SubscriptionsQuery.swift @@ -26,11 +26,11 @@ public extension DataService { let selection = Selection { try $0.on( - subscriptionsError: .init { - QueryResult.error(error: try $0.errorCodes().description) - }, subscriptionsSuccess: .init { QueryResult.success(result: try $0.subscriptions(selection: subsciptionSelection.list)) + }, + subscriptionsError: .init { + QueryResult.error(error: try $0.errorCodes().description) } ) }