From 4376124028c3132d1a07fc3f306ca8f98c1908f2 Mon Sep 17 00:00:00 2001 From: Jackson Harper Date: Thu, 26 May 2022 21:34:59 -0700 Subject: [PATCH] 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) } ) }