class AppDelegate: UIResponder, UIApplicationDelegate {
    ...
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        ...
        MUDeveloperToolsManager.setup()
        ...
    }

MULogManager.isEnabled = isDevelop
MUDeveloperToolsManager.isEnabled = isDevelop

extension Environments: MUDeveloperToolsDelegate {

    // MARK: - Environment

    private enum Environment {

        static let develop = "develop"
        static let production = "production"
    }

    // MARK: - Public methods

    func developerToolsEnvironmentArray() -> [MUEnvironment] {

        return [

            MUEnvironment(index: Environment.develop, title: "Develop"),
            MUEnvironment(index: Environment.production, title: "Production")
        ]
    }

    func developerToolsDidEnvironmentChanged(with environment: MUEnvironment) {

        switch environment.index {

        case Environment.develop    : Environments.isProduction = false
        case Environment.production : Environments.isProduction = true
        default                     : break
        }
    }
}

MUDeveloperToolsManager.delegate = self

func addDebugData(with data: String, to field: UITextField?) {
        
    if MUDeveloperToolsManager.shouldAutoCompleteForms {
       
        field?.value = value
    }
}

override func viewDidLoad() {
    ...
    addDebugData("test@test.com", to: emailTextField)
    ...
}

addDebugData(MUDevelopData.defaultEmail, to: emailTextField)
addDebugData(MUDevelopData.randomLogin, to: loginTextField)
addDebugData(MUDevelopData.randomPassword, to: passwordTextField)
addDebugData(MUDevelopData.randomPhone, to: phoneTextField)

addDebugData(MUDevelopData.previousLogin, to: loginTextField)
addDebugData(MUDevelopData.previousPassword, to: passwordTextField)

extension ViewController: MUDeveloperToolsCustomActionDelegate {

    func developerToolCustomActionDidTapped(_ developerTools: MUDeveloperToolsController) {
        ...
    }
}

MUDeveloperToolsManager.customActionDelegate = self

Log.details("...")
Log.event("...")
Log.error("...")
Log.critical("...")

MUDeveloperToolsManager.alwaysReturnConnectionError
MUDeveloperToolsManager.alwaysReturnServerError
MUDeveloperToolsManager.shouldSimulateBadConnection

if MUDeveloperToolsManager.alwaysReturnConnectionError {

    failure(MUNetworkError.connectionError)
}

class AppServerClient: MUDataTransferManager {
    ...
}

token = response.requestToken

override func getHeaders() -> [String : String] {
    
    var headers = super.getHeaders()
    headers.setValue(..., forKey: "Authorization")
    return headers
}

    override func handlerResponse(

        result    : Any,
        request   : MUNetworkRequest?,
        recipient : NSObject? = nil,
        success   : ((Any) -> Void)? = nil,
        failure   : ((Error?) -> Void)? = nil
    ) {
        
        guard ... else {
            
            failure?(AppError.parsingError)
            
            return
        }

        success?(result)
    }

    override func handleFailure(

        result     : Any?,
        error      : MUNetworkError?,
        request    : MUNetworkRequest?,
        recipient  : NSObject?,
        completion : ((Error?) -> Void)? = nil
    ) {
    
        return returnError(

            with      : AppError.convertNetworkError(error: error ?? MUNetworkError.unknownError),
            recipient : recipient,
            failure   : completion
        )
    }

enum AppError: Error, Equatable {
    
    case unknownError
    case parsingError
    case connectionError
    case temporaryNotAvalibleError
    case serverError
    case lostParameter(String)
    ...
}

extension AppError {

    static func convertNetworkError(error: MUNetworkError) -> AppError {

        switch error {

            case .connectionError         : return AppError.connectionError
            case .serverError             : return AppError.serverError
            case .parsingError            : return AppError.parsingError
            case .unknownError            : return AppError.unknownError
            ...
        }
    }
}

extension AppError {

    // MARK: - Public properties

    static var recipient: NSObject? { didSet { MUErrorManager.recipient = recipient } }

    // MARK: - Public methods

    static func post(with error: AppError, for recipient: NSObject? = nil) {

        MUErrorManager.post(with: error, for: recipient)
    }

    func post(for recipient: NSObject? = nil) {

        MUErrorManager.post(with: self, for: recipient)
    }
}

guard let login = login else {

   return AppError.lostParameter("login").post()
}

NotificationCenter.addObserver(for: self, forName: .appErrorDidCome) { [weak self] notification in
    
        guard let notification = notification.userInfo?["notification"] as? MUErrorNotification else {
            
            return AppError.unknownError.post()
        }
        
        guard notification.recipient == self else {
            
            return
        }
        
        Log.error("error: \(notification)")
        
        guard let error = notification.error as? AppError else {
            
            return
        }
        
        appErrorDidBecome(error: error)
}

final class Entity: MUModel, MUCodable {
    
    var primaryKey: String { return id }
    ...
}

class ViewController: MUViewController

class CatalogueController: ViewController {

    class override var storyboardName: String { return "Catalogue" }
}

MUViewController.defaultInstantiateMethod = .fromNib

CatalogueController.instantiate()

push(with: CatalogueController.self) { instance in

    instance.productId = productId
}

present(with: CatalogueController.self) { instance in

    instance.productId = productId
}

present(with: CatalogueController.self, withNavigation: true)

insert(controller: CatalogueController.instantiate(), into: self.view)
remove(child: childrenController)

override func appErrorDidBecome(error: Error) {

    guard let error = error as? AppError else {

        return
    }

    appErrorDidBecome(error: error)
}

func appErrorDidBecome(error: AppError) {

}

override func appErrorDidBecome(error: AppError) {
    ...
}

override var isErrorRecipient: Bool { false }

showPopup(

    title       : "Error",
    message     : AppError.unknownError.localizedDescription,
    buttonTitle : "Ok",
    action      : { ... }
)

showDialogAlert(

    title             : "Error",
    message           :  AppError.unknownError.localizedDescription,
    leftButtonTitle   : "Ok",
    rightButtonTitle  : "Cancel",
    leftButtonStyle   : .default,
    rightButtonStyle  : .cancel,
    leftButtonAction  : { ... },
    rightButtonAction : { ... }
)

showToast(

    title    : "Connection error",
    message  : AppError.connectionError.localizedDescription,
    duration : 2
)

show(

    customView     : CustomAlert.instantiate(),
    position       : .center,
    animationType  : .fade
)

show(controller: CatalogueController.instantiate())

showBottomPopup(

    controller           : TransactionController.instantiate(),
    backgroundColorStyle : backgroundColorStyle,
    arrowIcon            : R.image.common.icomCloseBottomPopup(),
    arrowIconOffset      : 8
)

popupControl.closeAll()

show(controller: CatalogueController.instantiate(), popupName: "CataloguePopup")
popupControl.isCurrentDisplaying(popupName: "CataloguePopup")

isLoading = true

MUActivityIndicatorControl.defaultStyle = .dark

indicatorControl.style = .lightLarge
indicatorControl.defaultDelay = 0.6

indicatorControl.isEnabled = false
loadControl.isEnabled = true

MULoadControl.multilineCornerRadius = 5
MULoadControl.multilineHeight = 15
MULoadControl.multilineLastLineFillPercent = 70
MULoadControl.gradientBaseColor = .white

loadControl.isManualSkeletonable = true
loadControl.shouldCreateOfEmptyItems = false

keyboardControl.containerView = keyboardContainer

IB keyboardContainer

override var hasScroll: Bool { true }

override var hasNavigationBar: Bool { false }

override var shouldRemoveFromNavigation: Bool { true }

override var interactivePopGestureEnabled: Bool { false }

guard isVisible, isFirstAppear else { return }

override func subscribeOnCustomNotifications() {
    
    NotificationCenter.addObserver(for: self, forName: .screenHistoryTransactionDidSuccess) { [weak self] _ in
        
        self?.requestObjects()
    }
}

class FormController: MUFormController

protocol VerifyFieldProtocol {
    
    var value: String { set get }
    var isError: Bool { set get }
    var errorMessage: String? { set get }
    func setError(on: Bool, message: String?)
}

addVerify(

    field.  : passwordField, 
    rules.  : [.required, .minLength(8)], 
    message : "Длина пароля должна быть не менее 8 символов".localize
)

enum MUValidateRule {
    
    case required
    case email
    case numeric
    case numericFloat
    case minLength(Int)
    case maxLength(Int)
    case minValue(Int)
    case maxValue(Int)
    case allowChar(String)
    case allowRegexp(String)
    case containsAtLeastOneOf([MURegexpClass])
}

guard isValid, isFilled else { return }

override func customValidate() -> Bool

override func afterValidate()

override func submitForm()

IB submitButton

IB continueButton

override var fieldsValidation: ValidationOption { .filledOnly }

enum ValidationOption: String {
   
    case all, filledOnly, activeFieldOnly
}

class ListController: MUListController

IB tableView: UITableView?
IB collectionView: UICollectionView?

class ArticleCell: MUTableCell {

    // MARK: - Override methods

    override func setup(with object: MUModel, sender: Any? = nil) {

        super.setup(with: object, sender: sender)

          ...
    }
}

registerNib(of: ListCell.self)

override func cellIdentifier(for object: MUModel, at indexPath: IndexPath) -> String?

tableControl.isAnimated = true
tableControl.animationStyle= .fade

final class Entity: MUModel, MUCodable {
    
    var primaryKey: String { return id }
    ...
}

objects = items
objects.append(item)

override func beginRequest()

requestObjects(withIndicator: true)

update(objects: items)

override var hasRefresh: Bool { true }

override var hasPagination: Bool { true }

let page = paginationControl.page

override func beginRequest() {

    interactor.getNews(id: tag.id, page: paginationControl.page) { [weak self] (items) in

        self?.update(objects: items)
    }
}

override var hasCache: Bool { true }

extension Product {
  
    static let cacheControl: MUCacheControlProtocol = MUCacheControlManager.get(for: Product.self)
}

override var cacheControl: MUCacheControlProtocol? { return Product.cacheControl }

cacheControl.save()
cacheControl.load()

String.format(time: Date())
String.format(time: Date(), style: .positional, units: [.hour, .minute, .second])

String.format(date: Date(), format: String = "d MMM, HH:mm")

String.format(number: number, minMantissa: 0, maxMantissa: 4)

String.format(price: price)
String.format(rub: priceInRub)

String.format(phone: phone)
String.format(phone: phone, to: .e164, onlyNumbers: true)
String.currentPhoneCoutryCode

guard String.check(email, regexp: "[0-9a-z]+") else { ... }

let marches = targetString.matches(for: "[a-zA-Z]+")

let string = rawString.replace(pattern: "[\s]+", with: "")

String.mask(template: "+7 999 999 99 99", value: phone)