    const testing = @import("std").testing;

    const high_bit = 1 << @typeInfo(usize).Int.bits - 1;

    pub const Status = enum(usize) {
        /// The operation completed successfully.
        Success = 0,

        /// The image failed to load.
        LoadError = high_bit | 1,

        /// A parameter was incorrect.
        InvalidParameter = high_bit | 2,

        /// The operation is not supported.
        Unsupported = high_bit | 3,

        /// The buffer was not the proper size for the request.
        BadBufferSize = high_bit | 4,

        /// The buffer is not large enough to hold the requested data. The required buffer size is returned in the appropriate parameter when this error occurs.
        BufferTooSmall = high_bit | 5,

        /// There is no data pending upon return.
        NotReady = high_bit | 6,

        /// The physical device reported an error while attempting the operation.
        DeviceError = high_bit | 7,

        /// The device cannot be written to.
        WriteProtected = high_bit | 8,

        /// A resource has run out.
        OutOfResources = high_bit | 9,

        /// An inconstancy was detected on the file system causing the operating to fail.
        VolumeCorrupted = high_bit | 10,

        /// There is no more space on the file system.
        VolumeFull = high_bit | 11,

        /// The device does not contain any medium to perform the operation.
        NoMedia = high_bit | 12,

        /// The medium in the device has changed since the last access.
        MediaChanged = high_bit | 13,

        /// The item was not found.
        NotFound = high_bit | 14,

        /// Access was denied.
        AccessDenied = high_bit | 15,

        /// The server was not found or did not respond to the request.
        NoResponse = high_bit | 16,

        /// A mapping to a device does not exist.
        NoMapping = high_bit | 17,

        /// The timeout time expired.
        Timeout = high_bit | 18,

        /// The protocol has not been started.
        NotStarted = high_bit | 19,

        /// The protocol has already been started.
        AlreadyStarted = high_bit | 20,

        /// The operation was aborted.
        Aborted = high_bit | 21,

        /// An ICMP error occurred during the network operation.
        IcmpError = high_bit | 22,

        /// A TFTP error occurred during the network operation.
        TftpError = high_bit | 23,

        /// A protocol error occurred during the network operation.
        ProtocolError = high_bit | 24,

        /// The function encountered an internal version that was incompatible with a version requested by the caller.
        IncompatibleVersion = high_bit | 25,

        /// The function was not performed due to a security violation.
        SecurityViolation = high_bit | 26,

        /// A CRC error was detected.
        CrcError = high_bit | 27,

        /// Beginning or end of media was reached
        EndOfMedia = high_bit | 28,

        /// The end of the file was reached.
        EndOfFile = high_bit | 31,

        /// The language specified was invalid.
        InvalidLanguage = high_bit | 32,

        /// The security status of the data is unknown or compromised and the data must be updated or replaced to restore a valid security status.
        CompromisedData = high_bit | 33,

        /// There is an address conflict address allocation
        IpAddressConflict = high_bit | 34,

        /// A HTTP error occurred during the network operation.
        HttpError = high_bit | 35,

        NetworkUnreachable = high_bit | 100,

        HostUnreachable = high_bit | 101,

        ProtocolUnreachable = high_bit | 102,

        PortUnreachable = high_bit | 103,

        ConnectionFin = high_bit | 104,

        ConnectionReset = high_bit | 105,

        ConnectionRefused = high_bit | 106,

        /// The string contained one or more characters that the device could not render and were skipped.
        WarnUnknownGlyph = 1,

        /// The handle was closed, but the file was not deleted.
        WarnDeleteFailure = 2,

        /// The handle was closed, but the data to the file was not flushed properly.
        WarnWriteFailure = 3,

        /// The resulting buffer was too small, and the data was truncated to the buffer size.
        WarnBufferTooSmall = 4,

        /// The data has not been updated within the timeframe set by localpolicy for this type of data.
        WarnStaleData = 5,

        /// The resulting buffer contains UEFI-compliant file system.
        WarnFileSystem = 6,

        /// The operation will be processed across a system reset.
        WarnResetRequired = 7,

        _,

        pub const EfiError = error{
            LoadError,
            InvalidParameter,
            Unsupported,
            BadBufferSize,
            BufferTooSmall,
            NotReady,
            DeviceError,
            WriteProtected,
            OutOfResources,
            VolumeCorrupted,
            VolumeFull,
            NoMedia,
            MediaChanged,
            NotFound,
            AccessDenied,
            NoResponse,
            NoMapping,
            Timeout,
            NotStarted,
            AlreadyStarted,
            Aborted,
            IcmpError,
            TftpError,
            ProtocolError,
            IncompatibleVersion,
            SecurityViolation,
            CrcError,
            EndOfMedia,
            EndOfFile,
            InvalidLanguage,
            CompromisedData,
            IpAddressConflict,
            HttpError,
            NetworkUnreachable,
            HostUnreachable,
            ProtocolUnreachable,
            PortUnreachable,
            ConnectionFin,
            ConnectionReset,
            ConnectionRefused,
        };

        pub fn err(self: Status) EfiError!void {
            inline for (@typeInfo(EfiError).ErrorSet.?) |efi_err| {
                if (self == @field(Status, efi_err.name)) {
                    return @field(EfiError, efi_err.name);
                }
            }
            // self is .Success or Warning

        }
    };

    test "status" {
        var st: Status = .DeviceError;
        try testing.expectError(error.DeviceError, st.err());

        st = .Success;
        try st.err();
    }