@k13engineering/linux-fuse 0.0.1 → 0.0.2

package/dist/lib/abi.js

@@ -0,0 +1,1019 @@
+import { define, types } from "ya-struct";
+import {
+  abi,
+  fuseAttrDefinition,
+  fuseFileLockDefinition,
+  fuseKstatfsDefinition,
+  uint16Array,
+  uint32Array,
+} from "./constants.js";
+
+/*type TStructParser<T> = {
+  size: number;
+  parse: ({ data }: { data: Uint8Array }) => T;
+  format: ({ value }: { value: T }) => Uint8Array;
+};*/
+
+/*type TFuseAttrValue = {
+  ino: bigint;
+  size: bigint;
+  blocks: bigint;
+  atime: bigint;
+  mtime: bigint;
+  ctime: bigint;
+  atimensec: bigint;
+  mtimensec: bigint;
+  ctimensec: bigint;
+  mode: bigint;
+  nlink: bigint;
+  uid: bigint;
+  gid: bigint;
+  rdev: bigint;
+  blksize: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseKstatfsValue = {
+  blocks: bigint;
+  bfree: bigint;
+  bavail: bigint;
+  files: bigint;
+  ffree: bigint;
+  bsize: bigint;
+  namelen: bigint;
+  frsize: bigint;
+  padding: bigint;
+  spare: bigint[];
+};*/
+
+/*type TFuseInHeaderValue = {
+  len: bigint;
+  opcode: bigint;
+  unique: bigint;
+  nodeid: bigint;
+  uid: bigint;
+  gid: bigint;
+  pid: bigint;
+  total_extlen: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseOutHeaderValue = {
+  len: bigint;
+  error: bigint;
+  unique: bigint;
+};*/
+
+/*type TFuseEntryOutValue = {
+  nodeid: bigint;
+  generation: bigint;
+  entry_valid: bigint;
+  attr_valid: bigint;
+  entry_valid_nsec: bigint;
+  attr_valid_nsec: bigint;
+  attr: TFuseAttrValue;
+};*/
+
+/*type TFuseGetattrInValue = {
+  getattr_flags: bigint;
+  dummy: bigint;
+  fh: bigint;
+};*/
+
+/*type TFuseAttrOutValue = {
+  attr_valid: bigint;
+  attr_valid_nsec: bigint;
+  dummy: bigint;
+  attr: TFuseAttrValue;
+};*/
+
+/*type TFuseSetattrInValue = {
+  valid: bigint;
+  padding: bigint;
+  fh: bigint;
+  size: bigint;
+  lock_owner: bigint;
+  atime: bigint;
+  mtime: bigint;
+  ctime: bigint;
+  atimensec: bigint;
+  mtimensec: bigint;
+  ctimensec: bigint;
+  mode: bigint;
+  unused4: bigint;
+  uid: bigint;
+  gid: bigint;
+  unused5: bigint;
+};*/
+
+/*type TFuseOpenInValue = {
+  flags: bigint;
+  open_flags: bigint;
+};*/
+
+/*type TFuseGetxattrInValue = {
+  size: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseGetxattrOutValue = {
+  size: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseCreateInValue = {
+  flags: bigint;
+  mode: bigint;
+  umask: bigint;
+  open_flags: bigint;
+};*/
+
+/*type TFuseOpenOutValue = {
+  fh: bigint;
+  open_flags: bigint;
+  backing_id: bigint;
+};*/
+
+/*type TFuseReleaseInValue = {
+  fh: bigint;
+  flags: bigint;
+  release_flags: bigint;
+  lock_owner: bigint;
+};*/
+
+/*type TFuseFlushInValue = {
+  fh: bigint;
+  unused: bigint;
+  padding: bigint;
+  lock_owner: bigint;
+};*/
+
+/*type TFuseReadInValue = {
+  fh: bigint;
+  offset: bigint;
+  size: bigint;
+  read_flags: bigint;
+  lock_owner: bigint;
+  flags: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseWriteInValue = {
+  fh: bigint;
+  offset: bigint;
+  size: bigint;
+  write_flags: bigint;
+  lock_owner: bigint;
+  flags: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseWriteOutValue = {
+  size: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseMkdirInValue = {
+  mode: bigint;
+  umask: bigint;
+};*/
+
+/*type TFuseMknodInValue = {
+  mode: bigint;
+  rdev: bigint;
+  umask: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseRenameInValue = {
+  newdir: bigint;
+};*/
+
+/*type TFuseLinkInValue = {
+  oldnodeid: bigint;
+};*/
+
+/*type TFuseRename2InValue = {
+  newdir: bigint;
+  flags: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseFileLockValue = {
+  start: bigint;
+  end: bigint;
+  type: bigint;
+  pid: bigint;
+};*/
+
+/*type TFuseLkInValue = {
+  fh: bigint;
+  owner: bigint;
+  lk: TFuseFileLockValue;
+  lk_flags: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseLkOutValue = {
+  lk: TFuseFileLockValue;
+};*/
+
+/*type TFuseInterruptInValue = {
+  unique: bigint;
+};*/
+
+/*type TFuseBmapInValue = {
+  block: bigint;
+  blocksize: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseBmapOutValue = {
+  block: bigint;
+};*/
+
+/*type TFuseIoctlInValue = {
+  fh: bigint;
+  flags: bigint;
+  cmd: bigint;
+  arg: bigint;
+  in_size: bigint;
+  out_size: bigint;
+};*/
+
+/*type TFuseIoctlOutValue = {
+  result: bigint;
+  flags: bigint;
+  in_iovs: bigint;
+  out_iovs: bigint;
+};*/
+
+/*type TFusePollInValue = {
+  fh: bigint;
+  kh: bigint;
+  flags: bigint;
+  events: bigint;
+};*/
+
+/*type TFusePollOutValue = {
+  revents: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseFallocateInValue = {
+  fh: bigint;
+  offset: bigint;
+  length: bigint;
+  mode: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseForgetInValue = {
+  nlookup: bigint;
+};*/
+
+/*type TFuseBatchForgetInValue = {
+  count: bigint;
+  dummy: bigint;
+};*/
+
+/*type TFuseForgetOneValue = {
+  nodeid: bigint;
+  nlookup: bigint;
+};*/
+
+/*type TFuseAccessInValue = {
+  mask: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseFsyncInValue = {
+  fh: bigint;
+  fsync_flags: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseSetxattrInValue = {
+  size: bigint;
+  flags: bigint;
+  setxattr_flags: bigint;
+  padding: bigint;
+};*/
+
+/*type TFuseInitInValue = {
+  major: bigint;
+  minor: bigint;
+  max_readahead: bigint;
+  flags: bigint;
+  flags2: bigint;
+  unused: bigint[];
+};*/
+
+/*type TFuseInitOutValue = {
+  major: bigint;
+  minor: bigint;
+  max_readahead: bigint;
+  flags: bigint;
+  max_background: bigint;
+  congestion_threshold: bigint;
+  max_write: bigint;
+  time_gran: bigint;
+  max_pages: bigint;
+  map_alignment: bigint;
+  flags2: bigint;
+  max_stack_depth: bigint;
+  request_timeout: bigint;
+  unused: bigint[];
+};*/
+
+/*type TFuseStatfsOutValue = {
+  st: TFuseKstatfsValue;
+};*/
+
+const fuseInHeaderParser/*: TStructParser<TFuseInHeaderValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "len", definition: types.UInt32 },
+      { name: "opcode", definition: types.UInt32 },
+      { name: "unique", definition: types.UInt64 },
+      { name: "nodeid", definition: types.UInt64 },
+      { name: "uid", definition: types.UInt32 },
+      { name: "gid", definition: types.UInt32 },
+      { name: "pid", definition: types.UInt32 },
+      { name: "total_extlen", definition: types.UInt16 },
+      { name: "padding", definition: types.UInt16 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseOutHeaderParser/*: TStructParser<TFuseOutHeaderValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "len", definition: types.UInt32 },
+      { name: "error", definition: types.Int32 },
+      { name: "unique", definition: types.UInt64 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseEntryOutParser/*: TStructParser<TFuseEntryOutValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "nodeid", definition: types.UInt64 },
+      { name: "generation", definition: types.UInt64 },
+      { name: "entry_valid", definition: types.UInt64 },
+      { name: "attr_valid", definition: types.UInt64 },
+      { name: "entry_valid_nsec", definition: types.UInt32 },
+      { name: "attr_valid_nsec", definition: types.UInt32 },
+      { name: "attr", definition: fuseAttrDefinition },
+    ],
+  },
+}).parser({ abi });
+
+const fuseGetattrInParser/*: TStructParser<TFuseGetattrInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "getattr_flags", definition: types.UInt32 },
+      { name: "dummy", definition: types.UInt32 },
+      { name: "fh", definition: types.UInt64 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseAttrOutParser/*: TStructParser<TFuseAttrOutValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "attr_valid", definition: types.UInt64 },
+      { name: "attr_valid_nsec", definition: types.UInt32 },
+      { name: "dummy", definition: types.UInt32 },
+      { name: "attr", definition: fuseAttrDefinition },
+    ],
+  },
+}).parser({ abi });
+
+const fuseSetattrInParser/*: TStructParser<TFuseSetattrInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "valid", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+      { name: "fh", definition: types.UInt64 },
+      { name: "size", definition: types.UInt64 },
+      { name: "lock_owner", definition: types.UInt64 },
+      { name: "atime", definition: types.UInt64 },
+      { name: "mtime", definition: types.UInt64 },
+      { name: "ctime", definition: types.UInt64 },
+      { name: "atimensec", definition: types.UInt32 },
+      { name: "mtimensec", definition: types.UInt32 },
+      { name: "ctimensec", definition: types.UInt32 },
+      { name: "mode", definition: types.UInt32 },
+      { name: "unused4", definition: types.UInt32 },
+      { name: "uid", definition: types.UInt32 },
+      { name: "gid", definition: types.UInt32 },
+      { name: "unused5", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseOpenInParser/*: TStructParser<TFuseOpenInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "flags", definition: types.UInt32 },
+      { name: "open_flags", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseGetxattrInParser/*: TStructParser<TFuseGetxattrInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "size", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseGetxattrOutParser/*: TStructParser<TFuseGetxattrOutValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "size", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseCreateInParser/*: TStructParser<TFuseCreateInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "flags", definition: types.UInt32 },
+      { name: "mode", definition: types.UInt32 },
+      { name: "umask", definition: types.UInt32 },
+      { name: "open_flags", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseOpenOutParser/*: TStructParser<TFuseOpenOutValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "fh", definition: types.UInt64 },
+      { name: "open_flags", definition: types.UInt32 },
+      { name: "backing_id", definition: types.Int32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseReleaseInParser/*: TStructParser<TFuseReleaseInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "fh", definition: types.UInt64 },
+      { name: "flags", definition: types.UInt32 },
+      { name: "release_flags", definition: types.UInt32 },
+      { name: "lock_owner", definition: types.UInt64 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseFlushInParser/*: TStructParser<TFuseFlushInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "fh", definition: types.UInt64 },
+      { name: "unused", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+      { name: "lock_owner", definition: types.UInt64 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseReadInParser/*: TStructParser<TFuseReadInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "fh", definition: types.UInt64 },
+      { name: "offset", definition: types.UInt64 },
+      { name: "size", definition: types.UInt32 },
+      { name: "read_flags", definition: types.UInt32 },
+      { name: "lock_owner", definition: types.UInt64 },
+      { name: "flags", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseWriteInParser/*: TStructParser<TFuseWriteInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "fh", definition: types.UInt64 },
+      { name: "offset", definition: types.UInt64 },
+      { name: "size", definition: types.UInt32 },
+      { name: "write_flags", definition: types.UInt32 },
+      { name: "lock_owner", definition: types.UInt64 },
+      { name: "flags", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseWriteOutParser/*: TStructParser<TFuseWriteOutValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "size", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseMkdirInParser/*: TStructParser<TFuseMkdirInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "mode", definition: types.UInt32 },
+      { name: "umask", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseMknodInParser/*: TStructParser<TFuseMknodInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "mode", definition: types.UInt32 },
+      { name: "rdev", definition: types.UInt32 },
+      { name: "umask", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseRenameInParser/*: TStructParser<TFuseRenameInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "newdir", definition: types.UInt64 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseRename2InParser/*: TStructParser<TFuseRename2InValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "newdir", definition: types.UInt64 },
+      { name: "flags", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseLinkInParser/*: TStructParser<TFuseLinkInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "oldnodeid", definition: types.UInt64 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseLkInParser/*: TStructParser<TFuseLkInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "fh", definition: types.UInt64 },
+      { name: "owner", definition: types.UInt64 },
+      { name: "lk", definition: fuseFileLockDefinition },
+      { name: "lk_flags", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseLkOutParser/*: TStructParser<TFuseLkOutValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "lk", definition: fuseFileLockDefinition },
+    ],
+  },
+}).parser({ abi });
+
+const fuseInterruptInParser/*: TStructParser<TFuseInterruptInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "unique", definition: types.UInt64 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseBmapInParser/*: TStructParser<TFuseBmapInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "block", definition: types.UInt64 },
+      { name: "blocksize", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseBmapOutParser/*: TStructParser<TFuseBmapOutValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "block", definition: types.UInt64 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseIoctlInParser/*: TStructParser<TFuseIoctlInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "fh", definition: types.UInt64 },
+      { name: "flags", definition: types.UInt32 },
+      { name: "cmd", definition: types.UInt32 },
+      { name: "arg", definition: types.UInt64 },
+      { name: "in_size", definition: types.UInt32 },
+      { name: "out_size", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseIoctlOutParser/*: TStructParser<TFuseIoctlOutValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "result", definition: types.Int32 },
+      { name: "flags", definition: types.UInt32 },
+      { name: "in_iovs", definition: types.UInt32 },
+      { name: "out_iovs", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fusePollInParser/*: TStructParser<TFusePollInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "fh", definition: types.UInt64 },
+      { name: "kh", definition: types.UInt64 },
+      { name: "flags", definition: types.UInt32 },
+      { name: "events", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fusePollOutParser/*: TStructParser<TFusePollOutValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "revents", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseFallocateInParser/*: TStructParser<TFuseFallocateInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "fh", definition: types.UInt64 },
+      { name: "offset", definition: types.UInt64 },
+      { name: "length", definition: types.UInt64 },
+      { name: "mode", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseForgetInParser/*: TStructParser<TFuseForgetInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "nlookup", definition: types.UInt64 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseBatchForgetInParser/*: TStructParser<TFuseBatchForgetInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "count", definition: types.UInt32 },
+      { name: "dummy", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseForgetOneParser/*: TStructParser<TFuseForgetOneValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "nodeid", definition: types.UInt64 },
+      { name: "nlookup", definition: types.UInt64 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseAccessInParser/*: TStructParser<TFuseAccessInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "mask", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseFsyncInParser/*: TStructParser<TFuseFsyncInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "fh", definition: types.UInt64 },
+      { name: "fsync_flags", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseSetxattrInParser/*: TStructParser<TFuseSetxattrInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "size", definition: types.UInt32 },
+      { name: "flags", definition: types.UInt32 },
+      { name: "setxattr_flags", definition: types.UInt32 },
+      { name: "padding", definition: types.UInt32 },
+    ],
+  },
+}).parser({ abi });
+
+const fuseInitInParser/*: TStructParser<TFuseInitInValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "major", definition: types.UInt32 },
+      { name: "minor", definition: types.UInt32 },
+      { name: "max_readahead", definition: types.UInt32 },
+      { name: "flags", definition: types.UInt32 },
+      { name: "flags2", definition: types.UInt32 },
+      { name: "unused", definition: uint32Array(11) },
+    ],
+  },
+}).parser({ abi });
+
+const fuseInitOutParser/*: TStructParser<TFuseInitOutValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "major", definition: types.UInt32 },
+      { name: "minor", definition: types.UInt32 },
+      { name: "max_readahead", definition: types.UInt32 },
+      { name: "flags", definition: types.UInt32 },
+      { name: "max_background", definition: types.UInt16 },
+      { name: "congestion_threshold", definition: types.UInt16 },
+      { name: "max_write", definition: types.UInt32 },
+      { name: "time_gran", definition: types.UInt32 },
+      { name: "max_pages", definition: types.UInt16 },
+      { name: "map_alignment", definition: types.UInt16 },
+      { name: "flags2", definition: types.UInt32 },
+      { name: "max_stack_depth", definition: types.UInt32 },
+      { name: "request_timeout", definition: types.UInt16 },
+      { name: "unused", definition: uint16Array(11) },
+    ],
+  },
+}).parser({ abi });
+
+const fuseStatfsOutParser/*: TStructParser<TFuseStatfsOutValue>*/ = define({
+  definition: {
+    type: "struct",
+    packed: false,
+    fixedAbi: {},
+    fields: [
+      { name: "st", definition: fuseKstatfsDefinition },
+    ],
+  },
+}).parser({ abi });
+
+const textEncoder = new TextEncoder();
+
+const toCString = (value/*: string*/) => {
+  const encoded = textEncoder.encode(value);
+  const result = new Uint8Array(encoded.length + 1);
+  result.set(encoded, 0);
+  return result;
+};
+
+const textDecoder = new TextDecoder();
+
+const decodeCString = (data/*: Uint8Array*/) => {
+  const nulIndex = data.indexOf(0);
+  const slice = nulIndex === -1 ? data : data.subarray(0, nulIndex);
+  return textDecoder.decode(slice);
+};
+
+const decodeCStringPair = (data/*: Uint8Array*/) => {
+  const firstTerminator = data.indexOf(0);
+  if (firstTerminator === -1) {
+    throw Error("expected first nul-terminated string");
+  }
+
+  const secondStart = firstTerminator + 1;
+  const secondTerminatorOffset = data.subarray(secondStart).indexOf(0);
+  if (secondTerminatorOffset === -1) {
+    throw Error("expected second nul-terminated string");
+  }
+
+  const secondTerminator = secondStart + secondTerminatorOffset;
+  return {
+    first: textDecoder.decode(data.subarray(0, firstTerminator)),
+    second: textDecoder.decode(data.subarray(secondStart, secondTerminator)),
+  };
+};
+
+export {
+
+  decodeCString,
+  decodeCStringPair,
+  toCString,
+
+  fuseAttrDefinition,
+  fuseCreateInParser,
+  fuseAttrOutParser,
+  fuseBatchForgetInParser,
+  fuseEntryOutParser,
+  fuseForgetInParser,
+  fuseForgetOneParser,
+  fuseGetattrInParser,
+  fuseGetxattrInParser,
+  fuseGetxattrOutParser,
+  fuseInHeaderParser,
+  fuseInitInParser,
+  fuseInitOutParser,
+  fuseAccessInParser,
+  fuseFlushInParser,
+  fuseKstatfsDefinition,
+  fuseMkdirInParser,
+  fuseMknodInParser,
+  fuseOpenInParser,
+  fuseOpenOutParser,
+  fuseOutHeaderParser,
+  fuseReadInParser,
+  fuseReleaseInParser,
+  fuseRename2InParser,
+  fuseRenameInParser,
+  fuseLinkInParser,
+  fuseLkInParser,
+  fuseLkOutParser,
+  fuseInterruptInParser,
+  fuseBmapInParser,
+  fuseBmapOutParser,
+  fuseIoctlInParser,
+  fuseIoctlOutParser,
+  fusePollInParser,
+  fusePollOutParser,
+  fuseFallocateInParser,
+  fuseSetattrInParser,
+  fuseSetxattrInParser,
+  fuseStatfsOutParser,
+  fuseWriteInParser,
+  fuseWriteOutParser,
+  fuseFsyncInParser,
+};
+
+/*export type {
+  TFuseInHeaderValue,
+  TFuseOutHeaderValue,
+  TFuseEntryOutValue,
+  TFuseAttrValue,
+  TFuseGetattrInValue,
+  TFuseAttrOutValue,
+  TFuseSetattrInValue,
+  TFuseOpenInValue,
+  TFuseGetxattrInValue,
+  TFuseGetxattrOutValue,
+  TFuseCreateInValue,
+  TFuseOpenOutValue,
+  TFuseReleaseInValue,
+  TFuseFlushInValue,
+  TFuseReadInValue,
+  TFuseWriteInValue,
+  TFuseWriteOutValue,
+  TFuseMkdirInValue,
+  TFuseMknodInValue,
+  TFuseRenameInValue,
+  TFuseRename2InValue,
+  TFuseLinkInValue,
+  TFuseForgetInValue,
+  TFuseBatchForgetInValue,
+  TFuseForgetOneValue,
+  TFuseAccessInValue,
+  TFuseFsyncInValue,
+  TFuseSetxattrInValue,
+  TFuseInitInValue,
+  TFuseInitOutValue,
+  TFuseStatfsOutValue,
+  TFuseFileLockValue,
+  TFuseLkInValue,
+  TFuseLkOutValue,
+  TFuseInterruptInValue,
+  TFuseBmapInValue,
+  TFuseBmapOutValue,
+  TFuseIoctlInValue,
+  TFuseIoctlOutValue,
+  TFusePollInValue,
+  TFusePollOutValue,
+  TFuseFallocateInValue,
+};*/