Пользовательская кодировка структуры

Возможное решение:

struct SignUpRequest: Encodable {
    let customer: Customer
    let password: String?
}

extension SignUpRequest {
    
    struct Customer: Encodable {
        let email: String?
        let firstname: String?
        let lastname: String?
        let privacy1: Bool
        let privacy2: Bool
        
        enum CustomerCodingKeys: String, CodingKey {
            case email
            case firstname
            case lastname
            case attributes = "custom_attributes"
        }
        
        func encode(to encoder: Encoder) throws {
            var container = encoder.container(keyedBy: CustomerCodingKeys.self)
            var codes: [AttributeCode] = []
            if privacy1 {
                codes.append(AttributeCode(value: "3", code: "consensopubb"))
            }
            if privacy2 {
                codes.append(AttributeCode(value: "5", code: "consensopubb2"))
            }
            try container.encode(codes, forKey: .attributes)
            try container.encode(email, forKey: .email)
            try container.encode(firstname, forKey: .firstname)
            try container.encode(lastname, forKey: .lastname)
        }
    }
}
extension SignUpRequest.Customer {
    struct AttributeCode: Encodable {
        
        let value: String
        let code: String
        
        enum AttributeCodingKeys: String, CodingKey {
            case code = "attribute_code"
            case value
        }
    }
}

Тестирование с:

let requests: [SignUpRequest] = [SignUpRequest(customer: .init(email: "email1", 
                                                               firstname: "f1",
                                                               lastname: "l1",
                                                               privacy1: true,
                                                               privacy2: true),
                                               password: "p1"),
                                 SignUpRequest(customer: .init(email: "email2", 
                                                               firstname: "f2",
                                                               lastname: "l2",
                                                               privacy1: false,
                                                               privacy2: true),
                                               password: "p2"),
                                 SignUpRequest(customer: .init(email: "email3", 
                                                               firstname: "f3",
                                                               lastname: "l3",
                                                               privacy1: true,
                                                               privacy2: false),
                                               password: "p3"),
                                 SignUpRequest(customer: .init(email: "email4", 
                                                               firstname: "f4",
                                                               lastname: "l4",
                                                               privacy1: false,
                                                               privacy2: false),
                                               password: "p4")]


requests.forEach { aRequest in
    do {
        let encoder = JSONEncoder()
        encoder.outputFormatting = [.prettyPrinted, .sortedKeys] //For debug purposes
        let data = try JSONEncoder().encode(aRequest)
        let jsonString = String(data: data, encoding: .utf8)!
        print(jsonString)
    } catch {
        print("Error: \(error)")
    }
}

Теперь я создал собственную структуру AttributeCode, чтобы упростить задачу. Конечно, вы можете настроить все encode и избежать этой структуры (что довольно просто, поскольку это [String: String], но я чувствую, что иногда, если encode(to:) слишком сложно для пользователя (для последующей отладки, модификаций) или encode(to:) не Это не достаточно ясно с первого взгляда, гораздо лучше иметь явную дополнительную структуру, при необходимости вы можете сделать ее частной, и ее сможет видеть только SignUpRequest.Customer.

Я сделал собственную кодировку для Customer, но на самом деле это можно сделать с другими модификациями для SignUpRequest, если только для этого нужна эта специальная кодировка, и вы не хотите изменять кодировку Customer (если это не сделано через более высокий SignUpRequest), но с этим у вас должна быть вся идея.

Обновлено: если вам действительно не нужна структура AttributedCode, вы можете написать:

var codes: [[String: String]] = []
if privacy1 {
    codes.append(["value": "3", "attribute_code": "consensopubb"])
}
if privacy2 {
    codes.append(["value": "5", "attribute_code": "consensopubb2"])
}
try container.encode(codes, forKey: .attributes)

Если бы это была [String: Any], это было бы сложнее, и я бы все равно предложил использовать структуру AttributedCode, поскольку ее легче читать на первый взгляд, но оба решения работают и действительны.