struct UserLogin: Codable {
    let status: Bool?
    let accessToken: String?
    let data: [UserLoginData]?
   ....
}

struct FailedResponse: Codable {
    let status: Bool?
    let error: ErrorResponse?

}

struct FailableResponse <T:Codable,E:Codable> : Codable {

    var success:T?
    var failure:E?

    public init(from decoder:Decoder) throws {

        let singleValue = try decoder.singleValueContainer()

        success = try singleValue.decode(T.self)
        failure = try singleValue.decode(E.self)

    }
}

APIClient.login(userName: self.loginViewModel.userName, password: self.loginViewModel.password) { (response:FailableResponse<UserLogin,FailedResponse>? , error) in

   }


// METHOD OF API CLIENT
// API CALLING
static func login<T:Codable>(userName:String,password:String,completion:@escaping completionResponse<T>) {
        self.performRequest(request: APIRouterUserModule.login(email: userName, password: password)) {(model) in

            self.handleResponseCallCompletion(result: model, completion: completion)
        }
  }
 // Parsing
 private static func handleResponseCallCompletion<T:Codable>(result:Result<Any>,completion:@escaping completionResponse<T>) {
        let object = CodableHelper<T>().decode(json: result)
        completion(object.object,object.error)
    }

struct UserLoginResponse: Codable {
    let status: Bool
    let error: ErrorResponse?
    let accessToken: String?
    let data: [UserLoginData]?
}

do {
    let responseObject = try decoder.decode(UserLoginResponse.self, from: data)
    switch responseObject.status {
    case true:
        guard let accessToken = responseObject.accessToken, let userLoginData = responseObject.data else {
            throw ParsingError.requiredFieldMissing
        }

        // use accessToken and userLoginData here

    case false:
        guard let errorObject = responseObject.error else {
            throw ParsingError.requiredFieldMissing
        }

        // use errorObject here
    }
} catch {
    print(error)
}

enum Result<Success, Failure> {
    case success(Success)
    case failure(Failure)
}

struct ApiResponse<T: Codable, E: Codable>: Codable {
    let status: Bool
    var result: Result<T, E>
    var error: E?

    enum CodingKeys: String, CodingKey {
        case status, error
    }

    init(from decoder: Decoder) throws {
        let values = try decoder.container(keyedBy: CodingKeys.self)
        status = try values.decode(Bool.self, forKey: .status)
        if status {
            let singleValue = try decoder.singleValueContainer()
            result = try .success(singleValue.decode(T.self))
        } else {
            result = try .failure(values.decode(E.self, forKey: .error))
        }
    }
}

do {
    let responseObject = try decoder.decode(ApiResponse<UserLoginResponse, ErrorResponse>.self, from: data)
    switch responseObject.result {
    case .success(let object):
        print(object.accessToken, object.data)

    case .failure(let error):
        print(error)
    }
} catch {
    print(error)
}