fileformat

type DiffEntry struct {
	Field  string `json:"field"`
	AField string `json:"a"`
	BField string `json:"b"`
	Same   bool   `json:"same"`
}

type DiffResult struct {
	FormatA    Format      `json:"format_a"`
	FormatB    Format      `json:"format_b"`
	SameFormat bool        `json:"same_format"`
	Entries    []DiffEntry `json:"entries"`
}

type Format string

type IRBuildParams struct {
	// Name is a display label for the remote. Optional — defaults to
	// "generated".
	Name string

	// Signals is the ordered list of IR entries. Each must have a
	// Name plus either parsed fields or raw fields populated.
	Signals []IRSignal
}

type IRFile struct {
	Filetype string
	Version  int
	Signals  []IRSignal
}

type IRSignal struct {
	Name      string
	Type      string
	Protocol  string
	Address   string
	Command   string
	Frequency int
	DutyCycle float64
	Data      []int
}

type MousejackPayloadParams struct {
	// Script is the DuckyScript body. Lines are trimmed and
	// empty/comment lines dropped. Whitespace-only input errors out.
	Script string

	// TargetOS hints the builder at expected key-combo conventions.
	// Valid: "windows", "macos", "linux". Empty defaults to windows.
	TargetOS string

	// MaxDelayMS caps the argument to any DELAY line. Mousejack
	// sessions are 2.4 GHz and flaky — very long delays often lose
	// sync with the receiver. Defaults to 5000 (5s); passing 0
	// applies the default.
	MaxDelayMS int
}

type NFCBuildParams struct {
	// DeviceType is one of "Mifare Classic", "Mifare Ultralight",
	// "NTAG213", "NTAG215", "NTAG216", etc. Accepted verbatim.
	DeviceType string

	// UID hex, e.g. "AA BB CC DD". Spaces between bytes are tolerated.
	UID string

	// ATQA / SAK are the ISO/IEC 14443 response bytes. Optional —
	// omitted for NTAG variants that don't expose them.
	ATQA string
	SAK  string

	// MifareType (e.g. "1K" / "4K") for Classic captures.
	MifareType string

	// Blocks maps block index → space-separated hex bytes. Optional
	// — a bare UID capture with no Blocks still produces a valid
	// file useful for UID-only emulation.
	Blocks map[int]string
}

type NFCFile struct {
	Filetype   string
	Version    int
	DeviceType string
	UID        string
	ATQA       string
	SAK        string
	MifareType string
	Blocks     map[int]string
	Headers    map[string]string
}

type NRF24Target struct {
	// Address is the 5-byte NRF24 pipe address, uppercase
	// colon-separated (e.g. "A1:B2:C3:D4:E5"). The Mouse Jacker FAP
	// matches bytes verbatim — whitespace or lowercase confuses it.
	Address string

	// Rate is the NRF24 data rate the sniffer observed the address at.
	// 1 = 1 Mbps (most Microsoft peripherals), 2 = 2 Mbps (Logitech
	// Unifying / MX family). A '250' value means 250 kbps, rare on
	// modern peripherals.
	Rate int
}

type RFIDBuildParams struct {
	// KeyType is the LF protocol name: EM4100, HIDProx, Indala,
	// AWID, FDX-A, FDX-B, etc. Accepted verbatim — the caller is
	// responsible for matching the protocol to the data.
	KeyType string

	// Data is the hex payload, e.g. "1A 2B 3C 4D 5E". Spaces
	// between octets are tolerated; non-hex input is rejected.
	Data string
}

type RFIDFile struct {
	Filetype string
	Version  int
	KeyType  string
	Data     string
	Headers  map[string]string
}

type SubBruteforceParams struct {
	Frequency uint32 // Hz
	BitCount  int    // typically 24 for Princeton-family protocols
	StartKey  uint64 // inclusive
	EndKey    uint64 // inclusive
	TE        int    // microseconds (defaults to 400 — common Princeton TE)
	Preset    string // optional; defaulted per-band via defaultSubPreset
}

type SubBuildParams struct {
	// Frequency in Hz (e.g. 433920000 for 433.92 MHz). Rejected if
	// zero or outside the 1 MHz–1 GHz range the Flipper CC1101 can
	// reach.
	Frequency uint32

	// Protocol name, e.g. "Princeton", "Keeloq", "RAW". Optional —
	// omitted files default to the RAW / unrecognised path.
	Protocol string

	// Preset name understood by the Flipper firmware. Leave empty to
	// have BuildSub pick a default from the frequency band.
	Preset string

	// Key is a space-separated hex byte string, e.g.
	// "1A 2B 3C 4D 00 00 00 00". Produces the Key: line.
	Key string

	// Bit is the protocol's bit-length (e.g. 24 for Princeton,
	// 32 for Came).
	Bit int

	// TE is the protocol's timing element in microseconds. Defaults
	// to 400 (a common Princeton TE) when zero and Protocol is set.
	TE int

	// RawData produces a RAW file instead of a keyed one. When set,
	// Protocol is overridden to "RAW".
	RawData []int32
}

type SubFile struct {
	Filetype  string
	Version   int
	Frequency uint32
	Preset    string
	Protocol  string
	Bit       int
	Key       string
	TE        int
	RawData   []int32
	Headers   map[string]string
}

type SubFreqSweepParams struct {
	Frequencies []uint32 // Hz, one file produced per entry
	BitCount    int
	StartKey    uint64
	EndKey      uint64
	TE          int
	Preset      string
}