From cd91b3b8bf91d8ab284902c625b6bd43c73cf21d Mon Sep 17 00:00:00 2001 From: Jackson Harper Date: Fri, 25 Nov 2022 13:42:12 +0800 Subject: [PATCH] Update schema --- .../Services/DataService/GQLSchema.swift | 1438 ++++++++++++++++- 1 file changed, 1436 insertions(+), 2 deletions(-) diff --git a/apple/OmnivoreKit/Sources/Services/DataService/GQLSchema.swift b/apple/OmnivoreKit/Sources/Services/DataService/GQLSchema.swift index f82d4a6fe..084d59147 100644 --- a/apple/OmnivoreKit/Sources/Services/DataService/GQLSchema.swift +++ b/apple/OmnivoreKit/Sources/Services/DataService/GQLSchema.swift @@ -4429,6 +4429,137 @@ extension Selection where TypeLock == Never, Type == Never { typealias DeleteReminderSuccess = Selection } +extension Objects { + struct DeleteRuleError { + let __typename: TypeName = .deleteRuleError + let errorCodes: [String: [Enums.DeleteRuleErrorCode]] + + enum TypeName: String, Codable { + case deleteRuleError = "DeleteRuleError" + } + } +} + +extension Objects.DeleteRuleError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.DeleteRuleErrorCode]?.self, forKey: 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.DeleteRuleError { + func errorCodes() throws -> [Enums.DeleteRuleErrorCode] { + 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 DeleteRuleError = Selection +} + +extension Objects { + struct DeleteRuleSuccess { + let __typename: TypeName = .deleteRuleSuccess + let rule: [String: Objects.Rule] + + enum TypeName: String, Codable { + case deleteRuleSuccess = "DeleteRuleSuccess" + } + } +} + +extension Objects.DeleteRuleSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "rule": + if let value = try container.decode(Objects.Rule?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + rule = map["rule"] + } +} + +extension Fields where TypeLock == Objects.DeleteRuleSuccess { + func rule(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "rule", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.rule[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteRuleSuccess = Selection +} + extension Objects { struct DeleteWebhookError { let __typename: TypeName = .deleteWebhookError @@ -4673,6 +4804,137 @@ extension Selection where TypeLock == Never, Type == Never { typealias DeviceToken = Selection } +extension Objects { + struct DeviceTokensError { + let __typename: TypeName = .deviceTokensError + let errorCodes: [String: [Enums.DeviceTokensErrorCode]] + + enum TypeName: String, Codable { + case deviceTokensError = "DeviceTokensError" + } + } +} + +extension Objects.DeviceTokensError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.DeviceTokensErrorCode]?.self, forKey: 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.DeviceTokensError { + func errorCodes() throws -> [Enums.DeviceTokensErrorCode] { + 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 DeviceTokensError = Selection +} + +extension Objects { + struct DeviceTokensSuccess { + let __typename: TypeName = .deviceTokensSuccess + let deviceTokens: [String: [Objects.DeviceToken]] + + enum TypeName: String, Codable { + case deviceTokensSuccess = "DeviceTokensSuccess" + } + } +} + +extension Objects.DeviceTokensSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "deviceTokens": + 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)." + ) + ) + } + } + + deviceTokens = map["deviceTokens"] + } +} + +extension Fields where TypeLock == Objects.DeviceTokensSuccess { + func deviceTokens(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "deviceTokens", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.deviceTokens[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeviceTokensSuccess = Selection +} + extension Objects { struct Feature { let __typename: TypeName = .feature @@ -8365,6 +8627,7 @@ extension Objects { let deleteNewsletterEmail: [String: Unions.DeleteNewsletterEmailResult] let deleteReaction: [String: Unions.DeleteReactionResult] let deleteReminder: [String: Unions.DeleteReminderResult] + let deleteRule: [String: Unions.DeleteRuleResult] let deleteWebhook: [String: Unions.DeleteWebhookResult] let generateApiKey: [String: Unions.GenerateApiKeyResult] let googleLogin: [String: Unions.LoginResult] @@ -8386,6 +8649,7 @@ extension Objects { let setLabels: [String: Unions.SetLabelsResult] let setLabelsForHighlight: [String: Unions.SetLabelsResult] let setLinkArchived: [String: Unions.ArchiveLinkResult] + let setRule: [String: Unions.SetRuleResult] let setShareArticle: [String: Unions.SetShareArticleResult] let setShareHighlight: [String: Unions.SetShareHighlightResult] let setUserPersonalization: [String: Unions.SetUserPersonalizationResult] @@ -8489,6 +8753,10 @@ extension Objects.Mutation: Decodable { if let value = try container.decode(Unions.DeleteReminderResult?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } + case "deleteRule": + if let value = try container.decode(Unions.DeleteRuleResult?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } case "deleteWebhook": if let value = try container.decode(Unions.DeleteWebhookResult?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) @@ -8573,6 +8841,10 @@ extension Objects.Mutation: Decodable { if let value = try container.decode(Unions.ArchiveLinkResult?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } + case "setRule": + if let value = try container.decode(Unions.SetRuleResult?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } case "setShareArticle": if let value = try container.decode(Unions.SetShareArticleResult?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) @@ -8664,6 +8936,7 @@ extension Objects.Mutation: Decodable { deleteNewsletterEmail = map["deleteNewsletterEmail"] deleteReaction = map["deleteReaction"] deleteReminder = map["deleteReminder"] + deleteRule = map["deleteRule"] deleteWebhook = map["deleteWebhook"] generateApiKey = map["generateApiKey"] googleLogin = map["googleLogin"] @@ -8685,6 +8958,7 @@ extension Objects.Mutation: Decodable { setLabels = map["setLabels"] setLabelsForHighlight = map["setLabelsForHighlight"] setLinkArchived = map["setLinkArchived"] + setRule = map["setRule"] setShareArticle = map["setShareArticle"] setShareHighlight = map["setShareHighlight"] setUserPersonalization = map["setUserPersonalization"] @@ -9028,6 +9302,25 @@ extension Fields where TypeLock == Objects.Mutation { } } + func deleteRule(id: String, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "deleteRule", + arguments: [Argument(name: "id", type: "ID!", value: id)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.deleteRule[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + func deleteWebhook(id: String, selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "deleteWebhook", @@ -9427,6 +9720,25 @@ extension Fields where TypeLock == Objects.Mutation { } } + func setRule(input: InputObjects.SetRuleInput, selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "setRule", + arguments: [Argument(name: "input", type: "SetRuleInput!", value: input)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.setRule[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", @@ -10790,6 +11102,7 @@ extension Objects { let article: [String: Unions.ArticleResult] let articleSavingRequest: [String: Unions.ArticleSavingRequestResult] let articles: [String: Unions.ArticlesResult] + let deviceTokens: [String: Unions.DeviceTokensResult] let feedArticles: [String: Unions.FeedArticlesResult] let getFollowers: [String: Unions.GetFollowersResult] let getFollowing: [String: Unions.GetFollowingResult] @@ -10801,6 +11114,7 @@ extension Objects { let newsletterEmails: [String: Unions.NewsletterEmailsResult] let recentSearches: [String: Unions.RecentSearchesResult] let reminder: [String: Unions.ReminderResult] + let rules: [String: Unions.RulesResult] let search: [String: Unions.SearchResult] let sendInstallInstructions: [String: Unions.SendInstallInstructionsResult] let sharedArticle: [String: Unions.SharedArticleResult] @@ -10847,6 +11161,10 @@ extension Objects.Query: Decodable { if let value = try container.decode(Unions.ArticlesResult?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } + case "deviceTokens": + if let value = try container.decode(Unions.DeviceTokensResult?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } case "feedArticles": if let value = try container.decode(Unions.FeedArticlesResult?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) @@ -10891,6 +11209,10 @@ extension Objects.Query: Decodable { if let value = try container.decode(Unions.ReminderResult?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } + case "rules": + if let value = try container.decode(Unions.RulesResult?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } case "search": if let value = try container.decode(Unions.SearchResult?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) @@ -10949,6 +11271,7 @@ extension Objects.Query: Decodable { article = map["article"] articleSavingRequest = map["articleSavingRequest"] articles = map["articles"] + deviceTokens = map["deviceTokens"] feedArticles = map["feedArticles"] getFollowers = map["getFollowers"] getFollowing = map["getFollowing"] @@ -10960,6 +11283,7 @@ extension Objects.Query: Decodable { newsletterEmails = map["newsletterEmails"] recentSearches = map["recentSearches"] reminder = map["reminder"] + rules = map["rules"] search = map["search"] sendInstallInstructions = map["sendInstallInstructions"] sharedArticle = map["sharedArticle"] @@ -11051,6 +11375,25 @@ extension Fields where TypeLock == Objects.Query { } } + func deviceTokens(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "deviceTokens", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.deviceTokens[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } + func feedArticles(after: OptionalArgument = .absent(), first: OptionalArgument = .absent(), sharedByUser: OptionalArgument = .absent(), sort: OptionalArgument = .absent(), selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "feedArticles", @@ -11253,6 +11596,25 @@ extension Fields where TypeLock == Objects.Query { } } + func rules(enabled: OptionalArgument = .absent(), selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "rules", + arguments: [Argument(name: "enabled", type: "Boolean", value: enabled)], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.rules[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", @@ -11348,10 +11710,10 @@ extension Fields where TypeLock == Objects.Query { } } - func updatesSince(after: OptionalArgument = .absent(), first: OptionalArgument = .absent(), since: DateTime, selection: Selection) throws -> Type { + func updatesSince(after: OptionalArgument = .absent(), first: OptionalArgument = .absent(), since: DateTime, sort: OptionalArgument = .absent(), selection: Selection) throws -> Type { let field = GraphQLField.composite( name: "updatesSince", - arguments: [Argument(name: "after", type: "String", value: after), Argument(name: "first", type: "Int", value: first), Argument(name: "since", type: "Date!", value: since)], + arguments: [Argument(name: "after", type: "String", value: after), Argument(name: "first", type: "Int", value: first), Argument(name: "since", type: "Date!", value: since), Argument(name: "sort", type: "SortParams", value: sort)], selection: selection.selection ) select(field) @@ -12464,6 +12826,436 @@ extension Selection where TypeLock == Never, Type == Never { typealias RevokeApiKeySuccess = Selection } +extension Objects { + struct Rule { + let __typename: TypeName = .rule + let actions: [String: [Objects.RuleAction]] + let createdAt: [String: DateTime] + let enabled: [String: Bool] + let filter: [String: String] + let id: [String: String] + let name: [String: String] + let updatedAt: [String: DateTime] + + enum TypeName: String, Codable { + case rule = "Rule" + } + } +} + +extension Objects.Rule: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "actions": + if let value = try container.decode([Objects.RuleAction]?.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 "enabled": + if let value = try container.decode(Bool?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "filter": + 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 "updatedAt": + if let value = try container.decode(DateTime?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + actions = map["actions"] + createdAt = map["createdAt"] + enabled = map["enabled"] + filter = map["filter"] + id = map["id"] + name = map["name"] + updatedAt = map["updatedAt"] + } +} + +extension Fields where TypeLock == Objects.Rule { + func actions(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "actions", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.actions[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + 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 enabled() throws -> Bool { + let field = GraphQLField.leaf( + name: "enabled", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.enabled[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return Bool.mockValue + } + } + + func filter() throws -> String { + let field = GraphQLField.leaf( + name: "filter", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.filter[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 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 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 Rule = Selection +} + +extension Objects { + struct RuleAction { + let __typename: TypeName = .ruleAction + let params: [String: [String]] + let type: [String: Enums.RuleActionType] + + enum TypeName: String, Codable { + case ruleAction = "RuleAction" + } + } +} + +extension Objects.RuleAction: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "params": + 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.RuleActionType?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + params = map["params"] + type = map["type"] + } +} + +extension Fields where TypeLock == Objects.RuleAction { + func params() throws -> [String] { + let field = GraphQLField.leaf( + name: "params", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.params[field.alias!] { + return data + } + throw HttpError.badpayload + case .mocking: + return [] + } + } + + func type() throws -> Enums.RuleActionType { + 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.RuleActionType.allCases.first! + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias RuleAction = Selection +} + +extension Objects { + struct RulesError { + let __typename: TypeName = .rulesError + let errorCodes: [String: [Enums.RulesErrorCode]] + + enum TypeName: String, Codable { + case rulesError = "RulesError" + } + } +} + +extension Objects.RulesError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.RulesErrorCode]?.self, forKey: 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.RulesError { + func errorCodes() throws -> [Enums.RulesErrorCode] { + 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 RulesError = Selection +} + +extension Objects { + struct RulesSuccess { + let __typename: TypeName = .rulesSuccess + let rules: [String: [Objects.Rule]] + + enum TypeName: String, Codable { + case rulesSuccess = "RulesSuccess" + } + } +} + +extension Objects.RulesSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "rules": + if let value = try container.decode([Objects.Rule]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + rules = map["rules"] + } +} + +extension Fields where TypeLock == Objects.RulesSuccess { + func rules(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "rules", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.rules[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias RulesSuccess = Selection +} + extension Objects { struct SaveArticleReadingProgressError { let __typename: TypeName = .saveArticleReadingProgressError @@ -14570,6 +15362,137 @@ extension Selection where TypeLock == Never, Type == Never { typealias SetLabelsSuccess = Selection } +extension Objects { + struct SetRuleError { + let __typename: TypeName = .setRuleError + let errorCodes: [String: [Enums.SetRuleErrorCode]] + + enum TypeName: String, Codable { + case setRuleError = "SetRuleError" + } + } +} + +extension Objects.SetRuleError: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SetRuleErrorCode]?.self, forKey: 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.SetRuleError { + func errorCodes() throws -> [Enums.SetRuleErrorCode] { + 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 SetRuleError = Selection +} + +extension Objects { + struct SetRuleSuccess { + let __typename: TypeName = .setRuleSuccess + let rule: [String: Objects.Rule] + + enum TypeName: String, Codable { + case setRuleSuccess = "SetRuleSuccess" + } + } +} + +extension Objects.SetRuleSuccess: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "rule": + if let value = try container.decode(Objects.Rule?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + default: + throw DecodingError.dataCorrupted( + DecodingError.Context( + codingPath: decoder.codingPath, + debugDescription: "Unknown key \(field)." + ) + ) + } + } + + rule = map["rule"] + } +} + +extension Fields where TypeLock == Objects.SetRuleSuccess { + func rule(selection: Selection) throws -> Type { + let field = GraphQLField.composite( + name: "rule", + arguments: [], + selection: selection.selection + ) + select(field) + + switch response { + case let .decoding(data): + if let data = data.rule[field.alias!] { + return try selection.decode(data: data) + } + throw HttpError.badpayload + case .mocking: + return selection.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetRuleSuccess = Selection +} + extension Objects { struct SetShareArticleError { let __typename: TypeName = .setShareArticleError @@ -18417,6 +19340,10 @@ extension Objects { let libraryLayoutType: [String: String] let librarySortOrder: [String: Enums.SortOrder] let margin: [String: Int] + let speechRate: [String: String] + let speechSecondaryVoice: [String: String] + let speechVoice: [String: String] + let speechVolume: [String: String] let theme: [String: String] enum TypeName: String, Codable { @@ -18461,6 +19388,22 @@ extension Objects.UserPersonalization: Decodable { if let value = try container.decode(Int?.self, forKey: codingKey) { map.set(key: field, hash: alias, value: value as Any) } + case "speechRate": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "speechSecondaryVoice": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "speechVoice": + if let value = try container.decode(String?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "speechVolume": + if let value = try container.decode(String?.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) @@ -18481,6 +19424,10 @@ extension Objects.UserPersonalization: Decodable { libraryLayoutType = map["libraryLayoutType"] librarySortOrder = map["librarySortOrder"] margin = map["margin"] + speechRate = map["speechRate"] + speechSecondaryVoice = map["speechSecondaryVoice"] + speechVoice = map["speechVoice"] + speechVolume = map["speechVolume"] theme = map["theme"] } } @@ -18576,6 +19523,66 @@ extension Fields where TypeLock == Objects.UserPersonalization { } } + func speechRate() throws -> String? { + let field = GraphQLField.leaf( + name: "speechRate", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.speechRate[field.alias!] + case .mocking: + return nil + } + } + + func speechSecondaryVoice() throws -> String? { + let field = GraphQLField.leaf( + name: "speechSecondaryVoice", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.speechSecondaryVoice[field.alias!] + case .mocking: + return nil + } + } + + func speechVoice() throws -> String? { + let field = GraphQLField.leaf( + name: "speechVoice", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.speechVoice[field.alias!] + case .mocking: + return nil + } + } + + func speechVolume() throws -> String? { + let field = GraphQLField.leaf( + name: "speechVolume", + arguments: [] + ) + select(field) + + switch response { + case let .decoding(data): + return data.speechVolume[field.alias!] + case .mocking: + return nil + } + } + func theme() throws -> String? { let field = GraphQLField.leaf( name: "theme", @@ -20947,6 +21954,80 @@ extension Selection where TypeLock == Never, Type == Never { typealias DeleteReminderResult = Selection } +extension Unions { + struct DeleteRuleResult { + let __typename: TypeName + let errorCodes: [String: [Enums.DeleteRuleErrorCode]] + let rule: [String: Objects.Rule] + + enum TypeName: String, Codable { + case deleteRuleError = "DeleteRuleError" + case deleteRuleSuccess = "DeleteRuleSuccess" + } + } +} + +extension Unions.DeleteRuleResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.DeleteRuleErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "rule": + if let value = try container.decode(Objects.Rule?.self, forKey: 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"] + rule = map["rule"] + } +} + +extension Fields where TypeLock == Unions.DeleteRuleResult { + func on(deleteRuleError: Selection, deleteRuleSuccess: Selection) throws -> Type { + select([GraphQLField.fragment(type: "DeleteRuleError", selection: deleteRuleError.selection), GraphQLField.fragment(type: "DeleteRuleSuccess", selection: deleteRuleSuccess.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .deleteRuleError: + let data = Objects.DeleteRuleError(errorCodes: data.errorCodes) + return try deleteRuleError.decode(data: data) + case .deleteRuleSuccess: + let data = Objects.DeleteRuleSuccess(rule: data.rule) + return try deleteRuleSuccess.decode(data: data) + } + case .mocking: + return deleteRuleError.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeleteRuleResult = Selection +} + extension Unions { struct DeleteWebhookResult { let __typename: TypeName @@ -21021,6 +22102,80 @@ extension Selection where TypeLock == Never, Type == Never { typealias DeleteWebhookResult = Selection } +extension Unions { + struct DeviceTokensResult { + let __typename: TypeName + let deviceTokens: [String: [Objects.DeviceToken]] + let errorCodes: [String: [Enums.DeviceTokensErrorCode]] + + enum TypeName: String, Codable { + case deviceTokensError = "DeviceTokensError" + case deviceTokensSuccess = "DeviceTokensSuccess" + } + } +} + +extension Unions.DeviceTokensResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "deviceTokens": + 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.DeviceTokensErrorCode]?.self, forKey: 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")!) + + deviceTokens = map["deviceTokens"] + errorCodes = map["errorCodes"] + } +} + +extension Fields where TypeLock == Unions.DeviceTokensResult { + func on(deviceTokensError: Selection, deviceTokensSuccess: Selection) throws -> Type { + select([GraphQLField.fragment(type: "DeviceTokensError", selection: deviceTokensError.selection), GraphQLField.fragment(type: "DeviceTokensSuccess", selection: deviceTokensSuccess.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .deviceTokensError: + let data = Objects.DeviceTokensError(errorCodes: data.errorCodes) + return try deviceTokensError.decode(data: data) + case .deviceTokensSuccess: + let data = Objects.DeviceTokensSuccess(deviceTokens: data.deviceTokens) + return try deviceTokensSuccess.decode(data: data) + } + case .mocking: + return deviceTokensError.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias DeviceTokensResult = Selection +} + extension Unions { struct FeedArticlesResult { let __typename: TypeName @@ -22291,6 +23446,80 @@ extension Selection where TypeLock == Never, Type == Never { typealias RevokeApiKeyResult = Selection } +extension Unions { + struct RulesResult { + let __typename: TypeName + let errorCodes: [String: [Enums.RulesErrorCode]] + let rules: [String: [Objects.Rule]] + + enum TypeName: String, Codable { + case rulesError = "RulesError" + case rulesSuccess = "RulesSuccess" + } + } +} + +extension Unions.RulesResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.RulesErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "rules": + if let value = try container.decode([Objects.Rule]?.self, forKey: 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"] + rules = map["rules"] + } +} + +extension Fields where TypeLock == Unions.RulesResult { + func on(rulesError: Selection, rulesSuccess: Selection) throws -> Type { + select([GraphQLField.fragment(type: "RulesError", selection: rulesError.selection), GraphQLField.fragment(type: "RulesSuccess", selection: rulesSuccess.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .rulesError: + let data = Objects.RulesError(errorCodes: data.errorCodes) + return try rulesError.decode(data: data) + case .rulesSuccess: + let data = Objects.RulesSuccess(rules: data.rules) + return try rulesSuccess.decode(data: data) + } + case .mocking: + return rulesError.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias RulesResult = Selection +} + extension Unions { struct SaveArticleReadingProgressResult { let __typename: TypeName @@ -22975,6 +24204,80 @@ extension Selection where TypeLock == Never, Type == Never { typealias SetLabelsResult = Selection } +extension Unions { + struct SetRuleResult { + let __typename: TypeName + let errorCodes: [String: [Enums.SetRuleErrorCode]] + let rule: [String: Objects.Rule] + + enum TypeName: String, Codable { + case setRuleError = "SetRuleError" + case setRuleSuccess = "SetRuleSuccess" + } + } +} + +extension Unions.SetRuleResult: Decodable { + init(from decoder: Decoder) throws { + let container = try decoder.container(keyedBy: DynamicCodingKeys.self) + + var map = HashMap() + for codingKey in container.allKeys { + if codingKey.isTypenameKey { continue } + + let alias = codingKey.stringValue + let field = GraphQLField.getFieldNameFromAlias(alias) + + switch field { + case "errorCodes": + if let value = try container.decode([Enums.SetRuleErrorCode]?.self, forKey: codingKey) { + map.set(key: field, hash: alias, value: value as Any) + } + case "rule": + if let value = try container.decode(Objects.Rule?.self, forKey: 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"] + rule = map["rule"] + } +} + +extension Fields where TypeLock == Unions.SetRuleResult { + func on(setRuleError: Selection, setRuleSuccess: Selection) throws -> Type { + select([GraphQLField.fragment(type: "SetRuleError", selection: setRuleError.selection), GraphQLField.fragment(type: "SetRuleSuccess", selection: setRuleSuccess.selection)]) + + switch response { + case let .decoding(data): + switch data.__typename { + case .setRuleError: + let data = Objects.SetRuleError(errorCodes: data.errorCodes) + return try setRuleError.decode(data: data) + case .setRuleSuccess: + let data = Objects.SetRuleSuccess(rule: data.rule) + return try setRuleSuccess.decode(data: data) + } + case .mocking: + return setRuleError.mock() + } + } +} + +extension Selection where TypeLock == Never, Type == Never { + typealias SetRuleResult = Selection +} + extension Unions { struct SetShareArticleResult { let __typename: TypeName @@ -25066,6 +26369,17 @@ extension Enums { } } +extension Enums { + /// DeleteRuleErrorCode + enum DeleteRuleErrorCode: String, CaseIterable, Codable { + case badRequest = "BAD_REQUEST" + + case notFound = "NOT_FOUND" + + case unauthorized = "UNAUTHORIZED" + } +} + extension Enums { /// DeleteWebhookErrorCode enum DeleteWebhookErrorCode: String, CaseIterable, Codable { @@ -25077,6 +26391,15 @@ extension Enums { } } +extension Enums { + /// DeviceTokensErrorCode + enum DeviceTokensErrorCode: String, CaseIterable, Codable { + case badRequest = "BAD_REQUEST" + + case unauthorized = "UNAUTHORIZED" + } +} + extension Enums { /// FeedArticlesErrorCode enum FeedArticlesErrorCode: String, CaseIterable, Codable { @@ -25291,6 +26614,28 @@ extension Enums { } } +extension Enums { + /// RuleActionType + enum RuleActionType: String, CaseIterable, Codable { + case addLabel = "ADD_LABEL" + + case archive = "ARCHIVE" + + case markAsRead = "MARK_AS_READ" + + case sendNotification = "SEND_NOTIFICATION" + } +} + +extension Enums { + /// RulesErrorCode + enum RulesErrorCode: String, CaseIterable, Codable { + case badRequest = "BAD_REQUEST" + + case unauthorized = "UNAUTHORIZED" + } +} + extension Enums { /// SaveArticleReadingProgressErrorCode enum SaveArticleReadingProgressErrorCode: String, CaseIterable, Codable { @@ -25305,6 +26650,8 @@ extension Enums { extension Enums { /// SaveErrorCode enum SaveErrorCode: String, CaseIterable, Codable { + case embeddedHighlightFailed = "EMBEDDED_HIGHLIGHT_FAILED" + case unauthorized = "UNAUTHORIZED" case unknown = "UNKNOWN" @@ -25386,6 +26733,17 @@ extension Enums { } } +extension Enums { + /// SetRuleErrorCode + enum SetRuleErrorCode: String, CaseIterable, Codable { + case badRequest = "BAD_REQUEST" + + case notFound = "NOT_FOUND" + + case unauthorized = "UNAUTHORIZED" + } +} + extension Enums { /// SetShareArticleErrorCode enum SetShareArticleErrorCode: String, CaseIterable, Codable { @@ -25409,6 +26767,8 @@ extension Enums { extension Enums { /// SetUserPersonalizationErrorCode enum SetUserPersonalizationErrorCode: String, CaseIterable, Codable { + case notFound = "NOT_FOUND" + case unauthorized = "UNAUTHORIZED" } } @@ -26236,6 +27596,25 @@ extension InputObjects { } } +extension InputObjects { + struct RuleActionInput: Encodable, Hashable { + var params: [String] + + var type: Enums.RuleActionType + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(params, forKey: .params) + try container.encode(type, forKey: .type) + } + + enum CodingKeys: String, CodingKey { + case params + case type + } + } +} + extension InputObjects { struct SaveArticleReadingProgressInput: Encodable, Hashable { var id: String @@ -26462,6 +27841,41 @@ extension InputObjects { } } +extension InputObjects { + struct SetRuleInput: Encodable, Hashable { + var actions: [InputObjects.RuleActionInput] + + var description: OptionalArgument = .absent() + + var enabled: Bool + + var filter: String + + var id: OptionalArgument = .absent() + + var name: String + + func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(actions, forKey: .actions) + if description.hasValue { try container.encode(description, forKey: .description) } + try container.encode(enabled, forKey: .enabled) + try container.encode(filter, forKey: .filter) + if id.hasValue { try container.encode(id, forKey: .id) } + try container.encode(name, forKey: .name) + } + + enum CodingKeys: String, CodingKey { + case actions + case description + case enabled + case filter + case id + case name + } + } +} + extension InputObjects { struct SetShareArticleInput: Encodable, Hashable { var articleId: String @@ -26520,6 +27934,14 @@ extension InputObjects { var margin: OptionalArgument = .absent() + var speechRate: OptionalArgument = .absent() + + var speechSecondaryVoice: OptionalArgument = .absent() + + var speechVoice: OptionalArgument = .absent() + + var speechVolume: OptionalArgument = .absent() + var theme: OptionalArgument = .absent() func encode(to encoder: Encoder) throws { @@ -26529,6 +27951,10 @@ extension InputObjects { 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 speechRate.hasValue { try container.encode(speechRate, forKey: .speechRate) } + if speechSecondaryVoice.hasValue { try container.encode(speechSecondaryVoice, forKey: .speechSecondaryVoice) } + if speechVoice.hasValue { try container.encode(speechVoice, forKey: .speechVoice) } + if speechVolume.hasValue { try container.encode(speechVolume, forKey: .speechVolume) } if theme.hasValue { try container.encode(theme, forKey: .theme) } } @@ -26538,6 +27964,10 @@ extension InputObjects { case libraryLayoutType case librarySortOrder case margin + case speechRate + case speechSecondaryVoice + case speechVoice + case speechVolume case theme } } @@ -26691,6 +28121,8 @@ extension InputObjects { extension InputObjects { struct UpdatePageInput: Encodable, Hashable { + var byline: OptionalArgument = .absent() + var description: OptionalArgument = .absent() var pageId: String @@ -26699,12 +28131,14 @@ extension InputObjects { func encode(to encoder: Encoder) throws { var container = encoder.container(keyedBy: CodingKeys.self) + if byline.hasValue { try container.encode(byline, forKey: .byline) } 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 byline case description case pageId case title