public init(language: FleksyKeyboardSDK.LanguageConfiguration = .init(),
              dataCapture: FleksyKeyboardSDK.DataCaptureMode = .disabled, 
              style: StyleConfiguration = .init(), 
              typing: TypingConfiguration = .init(), 
              apps: FleksyKeyboardSDK.AppsConfiguration = .init(), 
              customizationBundle: FleksyKeyboardSDK.CustomizationBundleConfiguration = .init(),
              license: LicenseConfiguration, 
              debug: DebugConfiguration = .init())

    override func createConfiguration() -> KeyboardConfiguration {
        // Configuration of the keyboard
     
        // Style
        let style = StyleConfiguration()
        
        // TypingConfiguration which includes punctuationSymbols
        let typing = TypingConfiguration()
      
        // LicenseConfiguration for the valdity of the license.
        let license = LicenseConfiguration(licenseKey: <licenseKey>, licenseSecret: <licenseSecret>)

        // KEYBOARD CONFIGURATION --
        // it groups capture, style and takes as constructor if we want a custom view or not + specific height
        //
        let config = KeyboardConfiguration(style: style,
                                         typing: typing,
                                         license: license)
        return config
    }

@property (copy, nonatomic, nullable) NSString *licenseSecret;

- (instancetype)initWithLicenseKey:(nonnull NSString *)licenseKey
                     licenseSecret:(nonnull NSString *)licenseSecret;

@end

let license = LicenseConfiguration(licenseKey: <licenseKey>, licenseSecret: <licenseSecret>)

    public convenience init(keyboardSize: FleksyKeyboardSDK.StyleConfiguration.KeyboardSize = .original, 
        keyboardFont: FleksyKeyboardSDK.StyleConfiguration.KeyboardFont = FleksyLegacySettings.getKeyboardFont() ?? .system(),
         spacebarLogoImage: @autoclosure @escaping () -> UIImage? = nil, 
         spacebarStyle: enumSpacebarStyle = .spacebarStyle_Automatic, 
         spacebarLogoContentMode: UIView.ContentMode = .center)

    final public let keyboardFont: FleksyKeyboardSDK.StyleConfiguration.KeyboardFont

    final public var spacebarLogoImage: UIImage? { get }
    final public var spacebarLogoContentMode: UIView.ContentMode { get }
    final public var spacebarStyle: enumSpacebarStyle
    
    final public var dictForceTheme: [String : Any]
    final public var dictForceDarkTheme: [String : Any]

public struct KeyboardTheme {
    /// Returns a new keyboard theme object from the passed JSON string.
    /// - Parameter jsonString: the JSON String containing the theme parameters.
    ///
    /// Note that if the jsonString contains an invalid KeyboardTheme structure then this initializer returns nil.
    public init?(jsonString: String)
    
    /// Returns a JSON String from the receiver's parameters.
    ///
    /// This JSON String can be used to initialize a KeyboardTheme object using the init(jsonString:) initializer.
    public func toJSONString() -> String?
}

public init(recent: [String] = FleksyManagedSettings.recentEmojis, 
	defaultSkinTone: FleksyKeyboardSDK.EmojiConfiguration.EmojiSkinTone = FleksyLegacySettings.getDefaultEmojiSkinTone() ?? .neutral)

/// Object used to configure the typing experience and features of the keyboard
public struct TypingConfiguration {

    public let caseSensitive: Bool

    public let smartPunctuation: Bool

    public let autoCorrect: Bool

    public let autoCorrectAfterPunctuation: Bool

    public let backspaceToUndoAutoCorrection: Bool

    public let autoCapitalization: Bool

    public let autoLearn: Bool

    public let doubleSpaceTapAddsPunctuation: Bool

    public let swipeTyping: Bool

    public let swipeTriggerLength: CGFloat

    public let swipeLeftToDelete: Bool

    public var punctuationSymbols: [String] { get }

    public var arrayPunctuationSymbols: [String]
    
    public let longPressShowsPunctuation: Bool

    public let keitaiEnabled: Bool

    public let keitaiDelay: TimeInterval

    public let spacebarMovesCursor: Bool

    public let useAllAccents: Bool

    public let magicButtonAction: FleksyKeyboardSDK.MagicButtonAction

    public var magicButtonLongPressActions: [FleksyKeyboardSDK.MagicButtonAction] { get }

    public let isMinimal: Bool

    public let numberRow: Bool
}

public struct FeedbackConfiguration : Equatable {

    public struct ResourceSoundSet : Equatable {

        /// The name of the sound file to play for different keys:
        public let tap: String
        public let button: String
        public let backspace: String

        /// Default SoundSet provided by Fleksy
        public static var defaultSoundSet: FleksyKeyboardSDK.FeedbackConfiguration.ResourceSoundSet { get }

        public init(tap: String, button: String? = nil, backspace: String? = nil)
    }

    public enum SoundMode : Equatable {
        case silent
        case sound(FleksyKeyboardSDK.FeedbackConfiguration.ResourceSoundSet = .defaultSoundSet)
    }

    public let soundMode: FleksyKeyboardSDK.FeedbackConfiguration.SoundMode

    public let haptics: Bool

    public init(soundMode: FleksyKeyboardSDK.FeedbackConfiguration.SoundMode = .silent, haptics: Bool = false)
}

/// An enum that defines the supported data capture modes by the SDK.
public enum DataCaptureMode {

    /// Data capture is disabled.
    case disabled

    /// Data capture is reported per-event in real time, i.e. data capture events are reported as soon as they happen.
    ///
    /// - Parameter configuration: The configuration defining the kind of events that should be reported. 
    ///                            Defaults to a EventDataConfiguration instance initialized with initialized with default parameters 
    ///
    case eventBased(configuration: FleksyKeyboardSDK.EventDataConfiguration = .init())

    /// Data capture is reported at the end of each keyboard session.
    /// - Parameter output: The type of output for the captured data. Defaults to enumCaptureOutput/captureOutput_file.
    /// - Parameter configuration: The specific configuration for the captured data. 
    ///                            
    /// - Parameter logEvents: A boolean indicating whether session-based data capture events should be logged. 
    ///                        Defaults to `false`
    case sessionBased(output: enumCaptureOutput = .captureOutput_file, configuration: FLDataConfiguration = .init(), logEvents: Bool = false)
}

let capture = DataCaptureMode.disabled

  /// Initial Configuration
  override func createConfiguration() -> KeyboardConfiguration {
      let eventDataConfiguration = EventDataConfiguration()
      let capture = DataCaptureMode.eventBased(configuration: eventDataConfiguration)
      [..]
      let config = KeyboardConfiguration(dataCapture: capture, ...)
      return config
   }
  
  [..]
  ///
  /// Override this method to start receiving the data preconfigured
  ///
  override func onDataCaptureEvent(_ event: EventBasedDataCaptureEvent) {
        #code#
    }

public init(keyStroke: Bool = true, 
            delete: Bool = true, 
            keyPlane: Bool = false, 
            word: Bool = true, 
            swipe: Bool = true, 
            sessionUpdate: Bool = true, 
            stressMonitor: Bool = true)

    override func onDataCaptureEvent(_ event: EventBasedDataCaptureEvent) {
        #code#
    }

  let dataConfig = FLDataConfiguration()
  let capture = DataCaptureMode.sessionBased(output: enumCaptureOutput.captureOutput_string, 
                                             configuration: dataConfig, 
                                             logEvents: false)

public convenience init(
    text: Bool = true, 
    swipe: Bool = true, 
    emoji: Bool = true, 
    layout: Bool = true, 
    textField: Bool = true, 
    language: Bool = true, 
    type: Bool = true, 
    area: Bool = true, 
    code: Bool = true, 
    position: Bool = true,
    press: Bool = true, 
    keyPress: Bool = true, 
    keyCenter: Bool = true, 
    keyBounds: Bool = true, 
    configCoordinate: enumDataConfigCoordinate = .dataConfigCoordinate_screenPixel, 
    word: Bool = true, 
    delete: Bool = true, 
    keyPlane: Bool = true, 
    keyText: Bool = true, 
    positionEnd: Bool = true, 
    keyPressEnd: Bool = true, 
    predictionsTouch: Bool = true, 
    prediction: Bool = true, 
    configFormat: enumDataConfigFormat = .dataConfigFormat_standard, 
    accelerometer: Bool = false, 
    autocorrection: Bool = true, 
    distanceFromLastTouch: Bool = true, 
    keyPositionLimited: Bool = false, 
    autocorrectionLimited: Bool = false, 
    wordLimited: Bool = false, 
    predictionLimited: Bool = false, 
    swipeLimited: Bool = false, 
    deleteLimited: Bool = false, 
    stressMonitor: Bool = false,
    interKeyTimeHistogram: Bool = true, 
    interKeyTimeHistogramInterval: Int = 50, 
    interKeyTimeHistogramCount: Int = 21)
    

public struct CustomizationBundleConfiguration {

    public struct Button {

        /// Creates a new ``Button`` object.
        ///
        /// - Parameters:
        ///   - label: The case-insensitive label of the custom button. This string must match (case insensitively) the `label` of the custom button defined in `keyboard-global.json` file.
        ///   - image: The image to be shown in the custom button. If the ``image`` is `nil`, then the ``label`` will be shown and it will be shown in uppercase or lowercase depending of the state of the shift button.
        ///   - contentMode: The content mode for the ``image``. Ignored if ``image`` is `nil`.
        ///   - action: The action to perform when the user taps the custom button, containing the `label` of the tapped button.
        ///     - The closure receives the `label` of the tapped button, but only compare this `label` string parameter in a case-insentive manner, because when the current keyboard is uppercase, then the `label` parameter will be uppercased.
        public init(label: String, image: @autoclosure @escaping () -> UIImage?, contentMode: UIView.ContentMode = .center, action: @escaping (String) -> Void)
    }

    /// The name of the bundle file that needs to be used for the keyboard layout customization. **Do not include the ".bundle" extension** in the `bundleFileName` parameter. Defautls to `"fleksy-custom`.
    ///
    /// Passing an empty string or a name for a bundle file that does not exist has no layout customization effect.
    public let bundleFileName: String

    /// The array of custom `Button`s to define the look and behavior of the custom buttons declared in the bundle file
    ///
    /// If two buttons in the array have the same label (case insensitive) then only the first one in the array will be considered.
    public let buttons: [FleksyKeyboardSDK.CustomizationBundleConfiguration.Button]

    /// Creates a new ``CustomizationBundleConfiguration`` object.
    /// - Parameters:
    ///   - bundleFileName: The name of the bundle file that needs to be used for the keyboard layout customization. Passing an empty string or a name for a bundle file that does not exist has no layout customization effect.
    ///   - buttons: The array of custom `Button`s to define the look and behavior of the custom buttons declared in the bundle file. If two buttons in the array have the same label (case insensitive) then only the first one in the array will be considered.
    public init(bundleFileName: String = "fleksy-custom", buttons: [FleksyKeyboardSDK.CustomizationBundleConfiguration.Button] = [])
   }

    public init(current: FleksyKeyboardSDK.KeyboardLanguage? = nil, 
    	userLanguages: [FleksyKeyboardSDK.KeyboardLanguage] = FleksyManagedSettings.userLanguages, 
    	automaticDownload: Bool = true)

    public let current: FleksyKeyboardSDK.KeyboardLanguage
    
    public let userLanguages: [FleksyKeyboardSDK.KeyboardLanguage]
    public let automaticDownload: Bool

@interface DebugConfiguration : NSObject

- (instancetype) initDebug;
@property (nonatomic) BOOL registerLayoutChange;
@end