# FrakLogLevel

```swift
enum FrakLogLevel
```

**Conforms to** `Swift.Comparable`, `Swift.Equatable`, `Swift.Hashable`, `Swift.RawRepresentable`, `Swift.Sendable`

Defined in: [Sources/FrakSDK/Core/FrakConfig.swift:15](https://github.com/frak-id/wallet/blob/35995d05c807efe1e0d6319fdede3ad363124d1e/sdk/ios/Sources/FrakSDK/Core/FrakConfig.swift#L15)

## Cases

### FrakLogLevel.debug

```swift
case debug
```

### FrakLogLevel.error

```swift
case error
```

### FrakLogLevel.info

```swift
case info
```

### FrakLogLevel.none

```swift
case none
```

### FrakLogLevel.warn

```swift
case warn
```

## Initializers

### init(rawValue:)

```swift
init?(rawValue: Int)
```

Creates a new instance with the specified raw value.

If there is no value of the type that corresponds with the specified raw
value, this initializer returns `nil`. For example:

    enum PaperSize: String {
        case A4, A5, Letter, Legal
    }

    print(PaperSize(rawValue: "Legal"))
    // Prints "Optional(PaperSize.Legal)"

    print(PaperSize(rawValue: "Tabloid"))
    // Prints "nil"

- Parameter rawValue: The raw value to use for the new instance.

## Properties

### hashValue

```swift
var hashValue: Int { get }
```

## Methods

### hash(into:)

```swift
func hash(into hasher: inout Hasher)
```

## Operators

### !=(_:_:)

```swift
static func != (lhs: Self, rhs: Self) -> Bool
```

Returns a Boolean value indicating whether two values are not equal.

Inequality is the inverse of equality. For any values `a` and `b`, `a != b`
implies that `a == b` is `false`.

This is the default implementation of the not-equal-to operator (`!=`)
for any type that conforms to `Equatable`.

- Parameters:
  - lhs: A value to compare.
  - rhs: Another value to compare.

### ...(_:_:)

```swift
static func ... (minimum: Self, maximum: Self) -> ClosedRange<Self>
```

Returns a closed range that contains both of its bounds.

Use the closed range operator (`...`) to create a closed range of any type
that conforms to the `Comparable` protocol. This example creates a
`ClosedRange<Character>` from "a" up to, and including, "z".

    let lowercase = "a"..."z"
    print(lowercase.contains("z"))
    // Prints "true"

- Parameters:
  - minimum: The lower bound for the range.
  - maximum: The upper bound for the range.

- Precondition: `minimum <= maximum`.

### ...(_:)

```swift
static func ... (maximum: Self) -> PartialRangeThrough<Self>
```

Returns a partial range up to, and including, its upper bound.

Use the prefix closed range operator (prefix `...`) to create a partial
range of any type that conforms to the `Comparable` protocol. This
example creates a `PartialRangeThrough<Double>` instance that includes
any value less than or equal to `5.0`.

    let throughFive = ...5.0

    throughFive.contains(4.0)     // true
    throughFive.contains(5.0)     // true
    throughFive.contains(6.0)     // false

You can use this type of partial range of a collection's indices to
represent the range from the start of the collection up to, and
including, the partial range's upper bound.

    let numbers = [10, 20, 30, 40, 50, 60, 70]
    print(numbers[...3])
    // Prints "[10, 20, 30, 40]"

- Parameter maximum: The upper bound for the range.

- Precondition: `maximum` must compare equal to itself (i.e. cannot be NaN).

### ...(_:)

```swift
static func ... (minimum: Self) -> PartialRangeFrom<Self>
```

Returns a partial range extending upward from a lower bound.

Use the postfix range operator (postfix `...`) to create a partial range
of any type that conforms to the `Comparable` protocol. This example
creates a `PartialRangeFrom<Double>` instance that includes any value
greater than or equal to `5.0`.

    let atLeastFive = 5.0...

    atLeastFive.contains(4.0)     // false
    atLeastFive.contains(5.0)     // true
    atLeastFive.contains(6.0)     // true

You can use this type of partial range of a collection's indices to
represent the range from the partial range's lower bound up to the end
of the collection.

    let numbers = [10, 20, 30, 40, 50, 60, 70]
    print(numbers[3...])
    // Prints "[40, 50, 60, 70]"

- Parameter minimum: The lower bound for the range.

- Precondition: `minimum` must compare equal to itself (i.e. cannot be NaN).

### ..<(_:_:)

```swift
static func ..< (minimum: Self, maximum: Self) -> Range<Self>
```

Returns a half-open range that contains its lower bound but not its upper
bound.

Use the half-open range operator (`..<`) to create a range of any type
that conforms to the `Comparable` protocol. This example creates a
`Range<Double>` from zero up to, but not including, 5.0.

    let lessThanFive = 0.0..<5.0
    print(lessThanFive.contains(3.14))  // Prints "true"
    print(lessThanFive.contains(5.0))   // Prints "false"

- Parameters:
  - minimum: The lower bound for the range.
  - maximum: The upper bound for the range.

- Precondition: `minimum <= maximum`.

### ..<(_:)

```swift
static func ..< (maximum: Self) -> PartialRangeUpTo<Self>
```

Returns a partial range up to, but not including, its upper bound.

Use the prefix half-open range operator (prefix `..<`) to create a
partial range of any type that conforms to the `Comparable` protocol.
This example creates a `PartialRangeUpTo<Double>` instance that includes
any value less than `5.0`.

    let upToFive = ..<5.0

    upToFive.contains(3.14)       // true
    upToFive.contains(6.28)       // false
    upToFive.contains(5.0)        // false

You can use this type of partial range of a collection's indices to
represent the range from the start of the collection up to, but not
including, the partial range's upper bound.

    let numbers = [10, 20, 30, 40, 50, 60, 70]
    print(numbers[..<3])
    // Prints "[10, 20, 30]"

- Parameter maximum: The upper bound for the range.

- Precondition: `maximum` must compare equal to itself (i.e. cannot be NaN).

### <(_:_:)

```swift
static func < (lhs: FrakLogLevel, rhs: FrakLogLevel) -> Bool
```

Returns a Boolean value indicating whether the value of the first
argument is less than that of the second argument.

This function is the only requirement of the `Comparable` protocol. The
remainder of the relational operator functions are implemented by the
standard library for any type that conforms to `Comparable`.

- Parameters:
  - lhs: A value to compare.
  - rhs: Another value to compare.

### <=(_:_:)

```swift
static func <= (lhs: Self, rhs: Self) -> Bool
```

Returns a Boolean value indicating whether the value of the first argument
is less than or equal to that of the second argument.

This is the default implementation of the less-than-or-equal-to
operator (`<=`) for any type that conforms to `Comparable`.

- Parameters:
  - lhs: A value to compare.
  - rhs: Another value to compare.

### >(_:_:)

```swift
static func > (lhs: Self, rhs: Self) -> Bool
```

Returns a Boolean value indicating whether the value of the first argument
is greater than that of the second argument.

This is the default implementation of the greater-than operator (`>`) for
any type that conforms to `Comparable`.

- Parameters:
  - lhs: A value to compare.
  - rhs: Another value to compare.

### >=(_:_:)

```swift
static func >= (lhs: Self, rhs: Self) -> Bool
```

Returns a Boolean value indicating whether the value of the first argument
is greater than or equal to that of the second argument.

This is the default implementation of the greater-than-or-equal-to operator
(`>=`) for any type that conforms to `Comparable`.

- Parameters:
  - lhs: A value to compare.
  - rhs: Another value to compare.
- Returns: `true` if `lhs` is greater than or equal to `rhs`; otherwise,
  `false`.