// доступ к буферу
T* buf();
operator T*();

// размер в кол-ве элементов
uint16_t size();

// размер в байтах
size_t sizeBytes();

// очистить (заполнить нулями)
void clear();

// изменить размер в количестве элементов T
bool resize(uint16_t size);

// удалить буфер
void reset();

// переместить (swap) из другого экземпляра
void move(array& other);

// экспортировать в файл
bool writeToFile(FS& fs, const char* path);

// импортировать из файла
bool readFromFile(FS& fs, const char* path);

// экспортировать в Stream (напр. файл)
bool writeTo(TS& stream);

// импортировать из Stream (напр. файл)
bool readFrom(TS& stream);

// добавить в конец
bool push(const T& val, ...);

// добавить, если нет элемента с таким значением
bool pushUniq(const T& val);

// добавить в конец
bool operator+=(const T& val);

// получить с конца и удалить
T pop();

// прочитать с конца не удаляя
T& last();

// добавить в начало
bool shift(const T& val);

// получить с начала и удалить
T unshift();

// прочитать с начала не удаляя
T& first();

// удалить элемент. Отрицательный - с конца
bool remove(int idx);

// удалить несколько элементов, начиная с индекса
bool remove(size_t from, size_t amount);

// вставить элемент на индекс (допускается индекс length())
bool insert(int idx, const T& val);

// прибавить другой массив в конец
bool concat(const stack_ext& st);
bool concat(const T* buf, size_t len, bool pgm = false);

// прибавить другой массив в конец
bool operator+=(const stack_ext& st);

// прибавить бинарные данные
size_t write(const void* buf, size_t len, bool pgm = false);

// заполнить значением (на capacity)
void fill(const T& val);

// инициализировать, вызвать конструкторы (на capacity)
void init();

// очистить (установить длину 0)
void clear();

// текущий размер в байтах
size_t size();

// количество элементов
size_t length();

// осталось свободного места, элементов
uint16_t left();

// установить количество элементов
bool setLength(size_t len);

// добавить количество элементов
bool addLength(size_t len);

// есть место для добавления
bool canAdd();

// вместимость, элементов
size_t capacity();

// вместимость, байт
size_t capacityBytes();

// позиция элемента (-1 если не найден)
int indexOf(const T& val);

// содержит элемент
bool has(const T& val);

// удалить по значению (true если элемента нет)
bool removeByVal(const T& val);

// получить элемент под индексом. Отрицательный - с конца
T& get(int idx);

// получить по индексу от начала без проверок. Отрицательный - с конца
T& operator[](int idx);

// доступ к буферу
T* buf();

// указатель на элемент, следующий за последним
T* end();

// буфер существует
bool valid();

// буфер существует
explicit operator bool();

// бинарный поиск в отсортированном стеке
bsearch_t<T> searchSort(const T& val);

// добавить с сортировкой. Флаг uniq - не добавлять если элемент уже есть
bool addSort(const T& val, bool uniq = false);

// добавить с сортировкой в bsearch_t из searchSort
bool addSort(const T& val, bsearch_t<T>& pos);

// сортировать стек
void sort();

// ДЛЯ ДИНАМИЧЕСКОГО
// установить увеличение размера для уменьшения количества мелких реаллокаций. Умолч. 8
void setOversize(uint16_t oversize);

// зарезервировать, элементов (установить новый размер буфера)
bool reserve(size_t size);

// освободить незанятое зарезервированное место
void shrink();

// зарезервировать, элементов (добавить к текущему размеру буфера)
bool addCapacity(size_t size);

// удалить буфер
void reset();

// подключить буфер
void setBuffer(T* buf, Ti capacity);

// запись в буфер. Вернёт true при успешной записи
bool write(const T& val);

// буфер полон
bool isFull();

// буфер пуст
bool isEmpty();

// чтение из буфера
T& read();

// возвращает крайнее значение без удаления из буфера
T& peek();

// получить по индексу от начала
T& get(Ti i);

// получить по индексу от начала без проверок. Отрицательный - с конца
T& operator[](Ti i);

// получить последний
T& getLast();

// количество непрочитанных элементов
size_t length();

// размер буфера
size_t size();

// очистить
void clear();

T* buffer;

// подключить буфер
void setBuffer(T* buf, Ti capacity);

// добавить в буфер
void write(T val);

// запись в буфер по номеру
void write(size_t n, T val);

// чтение из буфера по номеру
T& get(size_t n);

// получить по индексу от начала без проверок. Отрицательный - с конца
T& operator[](size_t n);

// позиция первого (левого) элемента
Ti getHead();

// размер буфера
size_t size();

// "очистить" буфер
void clear();

T* buffer = nullptr;

  lbuf_static<uint8_t, 8> buf;

  for (int i = 0; i < 12; i++) {
    buf.write(i);
    for (int j = 0; j < 8; j++) {
      Serial.print(buf.read(j));
      Serial.print(',');
    }
    Serial.println();
  }

// получить итератор
list_iter iter();

// добавить
bool add(list_node& node);

// добавить
bool add(list_node* node);

// удалить
void remove(list_node& node);

// удалить
void remove(list_node* node);

// список содержит
bool has(list_node& node);

// список содержит
bool has(list_node* node);

// длина списка
size_t length();

// очистить список
void clear();

// получить последний элемент в списке
list_node* getLast();