space-data-module-sdk 0.8.4 → 0.8.6

package/src/generated/http/cpp/HttpRequestAbi_generated.h

@@ -0,0 +1,285 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_HTTPREQUESTABI_SDN_HTTP_H_
+#define FLATBUFFERS_GENERATED_HTTPREQUESTABI_SDN_HTTP_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+// flatc version static_assert relaxed by generate-http-abi-bindings.mjs:
+// the HTTP envelope tables use only basic FlatBuffers features and are
+// inlined next to spacedatastandards.org headers pinned to a different
+// flatbuffers runtime version.
+
+namespace sdn {
+namespace http {
+
+struct HttpHeader;
+struct HttpHeaderBuilder;
+
+struct HttpRequest;
+struct HttpRequestBuilder;
+
+struct HttpHeader FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef HttpHeaderBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_VALUE = 6
+  };
+  /// Lower-cased header name. NAME is a FlatBuffers key so header vectors
+  /// are sorted and binary-searchable; encoders must sort by NAME.
+  const ::flatbuffers::String *NAME() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
+  }
+  bool KeyCompareLessThan(const HttpHeader * const o) const {
+    return *NAME() < *o->NAME();
+  }
+  int KeyCompareWithValue(const char *_NAME) const {
+    return strcmp(NAME()->c_str(), _NAME);
+  }
+  template<typename StringType>
+  int KeyCompareWithValue(const StringType& _NAME) const {
+    if (NAME()->c_str() < _NAME) return -1;
+    if (_NAME < NAME()->c_str()) return 1;
+    return 0;
+  }
+  const ::flatbuffers::String *VALUE() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_VALUE);
+  }
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffsetRequired(verifier, VT_NAME) &&
+           verifier.VerifyString(NAME()) &&
+           VerifyOffset(verifier, VT_VALUE) &&
+           verifier.VerifyString(VALUE()) &&
+           verifier.EndTable();
+  }
+};
+
+struct HttpHeaderBuilder {
+  typedef HttpHeader Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_NAME(::flatbuffers::Offset<::flatbuffers::String> NAME) {
+    fbb_.AddOffset(HttpHeader::VT_NAME, NAME);
+  }
+  void add_VALUE(::flatbuffers::Offset<::flatbuffers::String> VALUE) {
+    fbb_.AddOffset(HttpHeader::VT_VALUE, VALUE);
+  }
+  explicit HttpHeaderBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<HttpHeader> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<HttpHeader>(end);
+    fbb_.Required(o, HttpHeader::VT_NAME);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<HttpHeader> CreateHttpHeader(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> NAME = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> VALUE = 0) {
+  HttpHeaderBuilder builder_(_fbb);
+  builder_.add_VALUE(VALUE);
+  builder_.add_NAME(NAME);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<HttpHeader> CreateHttpHeaderDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const char *NAME = nullptr,
+    const char *VALUE = nullptr) {
+  auto NAME__ = NAME ? _fbb.CreateString(NAME) : 0;
+  auto VALUE__ = VALUE ? _fbb.CreateString(VALUE) : 0;
+  return sdn::http::CreateHttpHeader(
+      _fbb,
+      NAME__,
+      VALUE__);
+}
+
+struct HttpRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef HttpRequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_METHOD = 4,
+    VT_PATH = 6,
+    VT_QUERY = 8,
+    VT_HEADERS = 10,
+    VT_BODY = 12,
+    VT_REMOTE = 14
+  };
+  /// HTTP method verb, upper-case (GET, POST, ...).
+  const ::flatbuffers::String *METHOD() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_METHOD);
+  }
+  /// URL path only (no query string), e.g. "/api/v1/omm/bulk".
+  const ::flatbuffers::String *PATH() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_PATH);
+  }
+  /// Raw query string without the leading "?", still URL-encoded. The module
+  /// owns all parsing.
+  const ::flatbuffers::String *QUERY() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_QUERY);
+  }
+  /// Request headers, sorted by NAME.
+  const ::flatbuffers::Vector<::flatbuffers::Offset<sdn::http::HttpHeader>> *HEADERS() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<sdn::http::HttpHeader>> *>(VT_HEADERS);
+  }
+  /// Raw request body bytes (may be absent).
+  const ::flatbuffers::Vector<uint8_t> *BODY() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_BODY);
+  }
+  /// Remote address ("ip:port") as observed by the host pipe.
+  const ::flatbuffers::String *REMOTE() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_REMOTE);
+  }
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_METHOD) &&
+           verifier.VerifyString(METHOD()) &&
+           VerifyOffset(verifier, VT_PATH) &&
+           verifier.VerifyString(PATH()) &&
+           VerifyOffset(verifier, VT_QUERY) &&
+           verifier.VerifyString(QUERY()) &&
+           VerifyOffset(verifier, VT_HEADERS) &&
+           verifier.VerifyVector(HEADERS()) &&
+           verifier.VerifyVectorOfTables(HEADERS()) &&
+           VerifyOffset(verifier, VT_BODY) &&
+           verifier.VerifyVector(BODY()) &&
+           VerifyOffset(verifier, VT_REMOTE) &&
+           verifier.VerifyString(REMOTE()) &&
+           verifier.EndTable();
+  }
+};
+
+struct HttpRequestBuilder {
+  typedef HttpRequest Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_METHOD(::flatbuffers::Offset<::flatbuffers::String> METHOD) {
+    fbb_.AddOffset(HttpRequest::VT_METHOD, METHOD);
+  }
+  void add_PATH(::flatbuffers::Offset<::flatbuffers::String> PATH) {
+    fbb_.AddOffset(HttpRequest::VT_PATH, PATH);
+  }
+  void add_QUERY(::flatbuffers::Offset<::flatbuffers::String> QUERY) {
+    fbb_.AddOffset(HttpRequest::VT_QUERY, QUERY);
+  }
+  void add_HEADERS(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<sdn::http::HttpHeader>>> HEADERS) {
+    fbb_.AddOffset(HttpRequest::VT_HEADERS, HEADERS);
+  }
+  void add_BODY(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> BODY) {
+    fbb_.AddOffset(HttpRequest::VT_BODY, BODY);
+  }
+  void add_REMOTE(::flatbuffers::Offset<::flatbuffers::String> REMOTE) {
+    fbb_.AddOffset(HttpRequest::VT_REMOTE, REMOTE);
+  }
+  explicit HttpRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<HttpRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<HttpRequest>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<HttpRequest> CreateHttpRequest(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> METHOD = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> PATH = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> QUERY = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<sdn::http::HttpHeader>>> HEADERS = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> BODY = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> REMOTE = 0) {
+  HttpRequestBuilder builder_(_fbb);
+  builder_.add_REMOTE(REMOTE);
+  builder_.add_BODY(BODY);
+  builder_.add_HEADERS(HEADERS);
+  builder_.add_QUERY(QUERY);
+  builder_.add_PATH(PATH);
+  builder_.add_METHOD(METHOD);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<HttpRequest> CreateHttpRequestDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const char *METHOD = nullptr,
+    const char *PATH = nullptr,
+    const char *QUERY = nullptr,
+    std::vector<::flatbuffers::Offset<sdn::http::HttpHeader>> *HEADERS = nullptr,
+    const std::vector<uint8_t> *BODY = nullptr,
+    const char *REMOTE = nullptr) {
+  auto METHOD__ = METHOD ? _fbb.CreateString(METHOD) : 0;
+  auto PATH__ = PATH ? _fbb.CreateString(PATH) : 0;
+  auto QUERY__ = QUERY ? _fbb.CreateString(QUERY) : 0;
+  auto HEADERS__ = HEADERS ? _fbb.CreateVectorOfSortedTables<sdn::http::HttpHeader>(HEADERS) : 0;
+  auto BODY__ = BODY ? _fbb.CreateVector<uint8_t>(*BODY) : 0;
+  auto REMOTE__ = REMOTE ? _fbb.CreateString(REMOTE) : 0;
+  return sdn::http::CreateHttpRequest(
+      _fbb,
+      METHOD__,
+      PATH__,
+      QUERY__,
+      HEADERS__,
+      BODY__,
+      REMOTE__);
+}
+
+inline const sdn::http::HttpRequest *GetHttpRequest(const void *buf) {
+  return ::flatbuffers::GetRoot<sdn::http::HttpRequest>(buf);
+}
+
+inline const sdn::http::HttpRequest *GetSizePrefixedHttpRequest(const void *buf) {
+  return ::flatbuffers::GetSizePrefixedRoot<sdn::http::HttpRequest>(buf);
+}
+
+inline const char *HttpRequestIdentifier() {
+  return "$HTQ";
+}
+
+inline bool HttpRequestBufferHasIdentifier(const void *buf) {
+  return ::flatbuffers::BufferHasIdentifier(
+      buf, HttpRequestIdentifier());
+}
+
+inline bool SizePrefixedHttpRequestBufferHasIdentifier(const void *buf) {
+  return ::flatbuffers::BufferHasIdentifier(
+      buf, HttpRequestIdentifier(), true);
+}
+
+template <bool B = false>
+inline bool VerifyHttpRequestBuffer(
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
+  return verifier.template VerifyBuffer<sdn::http::HttpRequest>(HttpRequestIdentifier());
+}
+
+template <bool B = false>
+inline bool VerifySizePrefixedHttpRequestBuffer(
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<sdn::http::HttpRequest>(HttpRequestIdentifier());
+}
+
+inline void FinishHttpRequestBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<sdn::http::HttpRequest> root) {
+  fbb.Finish(root, HttpRequestIdentifier());
+}
+
+inline void FinishSizePrefixedHttpRequestBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<sdn::http::HttpRequest> root) {
+  fbb.FinishSizePrefixed(root, HttpRequestIdentifier());
+}
+
+}  // namespace http
+}  // namespace sdn
+
+#endif  // FLATBUFFERS_GENERATED_HTTPREQUESTABI_SDN_HTTP_H_

package/src/generated/http/cpp/HttpResponseAbi_generated.h

@@ -0,0 +1,192 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_HTTPRESPONSEABI_SDN_HTTP_H_
+#define FLATBUFFERS_GENERATED_HTTPRESPONSEABI_SDN_HTTP_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+// flatc version static_assert relaxed by generate-http-abi-bindings.mjs:
+// the HTTP envelope tables use only basic FlatBuffers features and are
+// inlined next to spacedatastandards.org headers pinned to a different
+// flatbuffers runtime version.
+
+#include "HttpRequestAbi_generated.h"
+
+namespace sdn {
+namespace http {
+
+struct HttpResponse;
+struct HttpResponseBuilder;
+
+struct HttpResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef HttpResponseBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_STATUS = 4,
+    VT_HEADERS = 6,
+    VT_BODY = 8,
+    VT_BODY_REF_TOKEN = 10,
+    VT_BODY_REF_SIZE = 12
+  };
+  /// HTTP status code (200, 304, 400, 404, 502, ...).
+  uint16_t STATUS() const {
+    return GetField<uint16_t>(VT_STATUS, 0);
+  }
+  /// Response headers, sorted by NAME. All content-type / caching / count
+  /// headers are decided inside the module.
+  const ::flatbuffers::Vector<::flatbuffers::Offset<sdn::http::HttpHeader>> *HEADERS() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<sdn::http::HttpHeader>> *>(VT_HEADERS);
+  }
+  /// Raw response body bytes (empty for 304).
+  const ::flatbuffers::Vector<uint8_t> *BODY() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_BODY);
+  }
+  /// OPTIONAL out-of-band body reference (near-zero-copy egress, loop C.5c).
+  /// When BODY_REF_SIZE > 0 (and BODY is absent), the body bytes do NOT
+  /// travel through the flow's linear memory: the module passes through the
+  /// opaque token it received from a capability hostcall that answered in
+  /// reference mode (e.g. storage.flatsql_*_stream with "deliver":"ref"),
+  /// and the host substitutes the exact byte buffer it registered under
+  /// that token. Still the dumb-pipe contract: the module DECIDED the body
+  /// (it made the query and forwarded the result reference); the host only
+  /// resolves its own token — a descriptor read, never a decision. Tokens
+  /// are scoped to the module instance's hostcall bridge and to the current
+  /// exchange.
+  uint64_t BODY_REF_TOKEN() const {
+    return GetField<uint64_t>(VT_BODY_REF_TOKEN, 0);
+  }
+  /// Byte length of the referenced body (0 = no reference present).
+  uint64_t BODY_REF_SIZE() const {
+    return GetField<uint64_t>(VT_BODY_REF_SIZE, 0);
+  }
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint16_t>(verifier, VT_STATUS, 2) &&
+           VerifyOffset(verifier, VT_HEADERS) &&
+           verifier.VerifyVector(HEADERS()) &&
+           verifier.VerifyVectorOfTables(HEADERS()) &&
+           VerifyOffset(verifier, VT_BODY) &&
+           verifier.VerifyVector(BODY()) &&
+           VerifyField<uint64_t>(verifier, VT_BODY_REF_TOKEN, 8) &&
+           VerifyField<uint64_t>(verifier, VT_BODY_REF_SIZE, 8) &&
+           verifier.EndTable();
+  }
+};
+
+struct HttpResponseBuilder {
+  typedef HttpResponse Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_STATUS(uint16_t STATUS) {
+    fbb_.AddElement<uint16_t>(HttpResponse::VT_STATUS, STATUS, 0);
+  }
+  void add_HEADERS(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<sdn::http::HttpHeader>>> HEADERS) {
+    fbb_.AddOffset(HttpResponse::VT_HEADERS, HEADERS);
+  }
+  void add_BODY(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> BODY) {
+    fbb_.AddOffset(HttpResponse::VT_BODY, BODY);
+  }
+  void add_BODY_REF_TOKEN(uint64_t BODY_REF_TOKEN) {
+    fbb_.AddElement<uint64_t>(HttpResponse::VT_BODY_REF_TOKEN, BODY_REF_TOKEN, 0);
+  }
+  void add_BODY_REF_SIZE(uint64_t BODY_REF_SIZE) {
+    fbb_.AddElement<uint64_t>(HttpResponse::VT_BODY_REF_SIZE, BODY_REF_SIZE, 0);
+  }
+  explicit HttpResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<HttpResponse> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<HttpResponse>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<HttpResponse> CreateHttpResponse(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint16_t STATUS = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<sdn::http::HttpHeader>>> HEADERS = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> BODY = 0,
+    uint64_t BODY_REF_TOKEN = 0,
+    uint64_t BODY_REF_SIZE = 0) {
+  HttpResponseBuilder builder_(_fbb);
+  builder_.add_BODY_REF_SIZE(BODY_REF_SIZE);
+  builder_.add_BODY_REF_TOKEN(BODY_REF_TOKEN);
+  builder_.add_BODY(BODY);
+  builder_.add_HEADERS(HEADERS);
+  builder_.add_STATUS(STATUS);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<HttpResponse> CreateHttpResponseDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint16_t STATUS = 0,
+    std::vector<::flatbuffers::Offset<sdn::http::HttpHeader>> *HEADERS = nullptr,
+    const std::vector<uint8_t> *BODY = nullptr,
+    uint64_t BODY_REF_TOKEN = 0,
+    uint64_t BODY_REF_SIZE = 0) {
+  auto HEADERS__ = HEADERS ? _fbb.CreateVectorOfSortedTables<sdn::http::HttpHeader>(HEADERS) : 0;
+  auto BODY__ = BODY ? _fbb.CreateVector<uint8_t>(*BODY) : 0;
+  return sdn::http::CreateHttpResponse(
+      _fbb,
+      STATUS,
+      HEADERS__,
+      BODY__,
+      BODY_REF_TOKEN,
+      BODY_REF_SIZE);
+}
+
+inline const sdn::http::HttpResponse *GetHttpResponse(const void *buf) {
+  return ::flatbuffers::GetRoot<sdn::http::HttpResponse>(buf);
+}
+
+inline const sdn::http::HttpResponse *GetSizePrefixedHttpResponse(const void *buf) {
+  return ::flatbuffers::GetSizePrefixedRoot<sdn::http::HttpResponse>(buf);
+}
+
+inline const char *HttpResponseIdentifier() {
+  return "$HTR";
+}
+
+inline bool HttpResponseBufferHasIdentifier(const void *buf) {
+  return ::flatbuffers::BufferHasIdentifier(
+      buf, HttpResponseIdentifier());
+}
+
+inline bool SizePrefixedHttpResponseBufferHasIdentifier(const void *buf) {
+  return ::flatbuffers::BufferHasIdentifier(
+      buf, HttpResponseIdentifier(), true);
+}
+
+template <bool B = false>
+inline bool VerifyHttpResponseBuffer(
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
+  return verifier.template VerifyBuffer<sdn::http::HttpResponse>(HttpResponseIdentifier());
+}
+
+template <bool B = false>
+inline bool VerifySizePrefixedHttpResponseBuffer(
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<sdn::http::HttpResponse>(HttpResponseIdentifier());
+}
+
+inline void FinishHttpResponseBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<sdn::http::HttpResponse> root) {
+  fbb.Finish(root, HttpResponseIdentifier());
+}
+
+inline void FinishSizePrefixedHttpResponseBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<sdn::http::HttpResponse> root) {
+  fbb.FinishSizePrefixed(root, HttpResponseIdentifier());
+}
+
+}  // namespace http
+}  // namespace sdn
+
+#endif  // FLATBUFFERS_GENERATED_HTTPRESPONSEABI_SDN_HTTP_H_

package/src/generated/http/sdn/http/http-header.js

@@ -0,0 +1,53 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import * as flatbuffers from "flatbuffers";
+class HttpHeader {
+  constructor() {
+    __publicField(this, "bb", null);
+    __publicField(this, "bb_pos", 0);
+  }
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+  static getRootAsHttpHeader(bb, obj) {
+    return (obj || new HttpHeader()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  static getSizePrefixedRootAsHttpHeader(bb, obj) {
+    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+    return (obj || new HttpHeader()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  name(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return this.bb.__string(this.bb_pos + offset, optionalEncoding);
+  }
+  value(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  static startHttpHeader(builder) {
+    builder.startObject(2);
+  }
+  static addName(builder, nameOffset) {
+    builder.addFieldOffset(0, nameOffset, 0);
+  }
+  static addValue(builder, valueOffset) {
+    builder.addFieldOffset(1, valueOffset, 0);
+  }
+  static endHttpHeader(builder) {
+    const offset = builder.endObject();
+    builder.requiredField(offset, 4);
+    return offset;
+  }
+  static createHttpHeader(builder, nameOffset, valueOffset) {
+    HttpHeader.startHttpHeader(builder);
+    HttpHeader.addName(builder, nameOffset);
+    HttpHeader.addValue(builder, valueOffset);
+    return HttpHeader.endHttpHeader(builder);
+  }
+}
+export {
+  HttpHeader
+};

package/src/generated/http/sdn/http/http-header.ts

@@ -0,0 +1,67 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import * as flatbuffers from 'flatbuffers';
+
+export class HttpHeader {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):HttpHeader {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsHttpHeader(bb:flatbuffers.ByteBuffer, obj?:HttpHeader):HttpHeader {
+  return (obj || new HttpHeader()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsHttpHeader(bb:flatbuffers.ByteBuffer, obj?:HttpHeader):HttpHeader {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new HttpHeader()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+/**
+ * Lower-cased header name. NAME is a FlatBuffers key so header vectors
+ * are sorted and binary-searchable; encoders must sort by NAME.
+ */
+name():string
+name(optionalEncoding:flatbuffers.Encoding):string|Uint8Array
+name(optionalEncoding?:any):string|Uint8Array {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return this.bb!.__string(this.bb_pos + offset, optionalEncoding);
+}
+
+value():string|null
+value(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+value(optionalEncoding?:any):string|Uint8Array|null {
+  const offset = this.bb!.__offset(this.bb_pos, 6);
+  return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+}
+
+static startHttpHeader(builder:flatbuffers.Builder) {
+  builder.startObject(2);
+}
+
+static addName(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset) {
+  builder.addFieldOffset(0, nameOffset, 0);
+}
+
+static addValue(builder:flatbuffers.Builder, valueOffset:flatbuffers.Offset) {
+  builder.addFieldOffset(1, valueOffset, 0);
+}
+
+static endHttpHeader(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  builder.requiredField(offset, 4) // NAME
+  return offset;
+}
+
+static createHttpHeader(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset, valueOffset:flatbuffers.Offset):flatbuffers.Offset {
+  HttpHeader.startHttpHeader(builder);
+  HttpHeader.addName(builder, nameOffset);
+  HttpHeader.addValue(builder, valueOffset);
+  return HttpHeader.endHttpHeader(builder);
+}
+}