@k13engineering/linux-fuse 0.0.7 → 0.1.0

package/dist/lib/abi.js

@@ -31,7 +31,7 @@ import {
   gid: bigint;
   rdev: bigint;
   blksize: bigint;
-  padding: bigint;
+  flags: bigint;
 };*/
 
 /*type TFuseKstatfsValue = {
@@ -419,652 +419,746 @@ import {
   stat: TFuseStatxValue;
 };*/
 
+const fuseInHeaderDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseInHeaderDefinition,
 }).parser({ abi });
 
+const fuseOutHeaderDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "len", definition: types.UInt32 },
+    { name: "error", definition: types.Int32 },
+    { name: "unique", definition: types.UInt64 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseOutHeaderDefinition,
 }).parser({ abi });
 
+const fuseEntryOutDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseEntryOutDefinition,
 }).parser({ abi });
 
+const fuseGetattrInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "getattr_flags", definition: types.UInt32 },
+    { name: "dummy", definition: types.UInt32 },
+    { name: "fh", definition: types.UInt64 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseGetattrInDefinition,
 }).parser({ abi });
 
+const fuseAttrOutDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseAttrOutDefinition,
 }).parser({ abi });
 
+const fuseSetattrInDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseSetattrInDefinition,
 }).parser({ abi });
 
+const fuseOpenInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "flags", definition: types.UInt32 },
+    { name: "open_flags", definition: types.UInt32 },
+  ],
+} /*as const*/;
+
 const fuseOpenInParser/*: TStructParser<TFuseOpenInValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "flags", definition: types.UInt32 },
-      { name: "open_flags", definition: types.UInt32 },
-    ],
-  },
+  definition: fuseOpenInDefinition,
 }).parser({ abi });
 
+const fuseGetxattrInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "size", definition: types.UInt32 },
+    { name: "padding", definition: types.UInt32 },
+  ],
+} /*as const*/;
+
 const fuseGetxattrInParser/*: TStructParser<TFuseGetxattrInValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "size", definition: types.UInt32 },
-      { name: "padding", definition: types.UInt32 },
-    ],
-  },
+  definition: fuseGetxattrInDefinition,
 }).parser({ abi });
 
+const fuseGetxattrOutDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "size", definition: types.UInt32 },
+    { name: "padding", definition: types.UInt32 },
+  ],
+} /*as const*/;
+
 const fuseGetxattrOutParser/*: TStructParser<TFuseGetxattrOutValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "size", definition: types.UInt32 },
-      { name: "padding", definition: types.UInt32 },
-    ],
-  },
+  definition: fuseGetxattrOutDefinition,
 }).parser({ abi });
 
+const fuseCreateInDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseCreateInDefinition,
 }).parser({ abi });
 
+const fuseOpenOutDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "fh", definition: types.UInt64 },
+    { name: "open_flags", definition: types.UInt32 },
+    { name: "backing_id", definition: types.Int32 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseOpenOutDefinition,
 }).parser({ abi });
 
+const fuseReleaseInDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseReleaseInDefinition,
 }).parser({ abi });
 
+const fuseFlushInDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseFlushInDefinition,
 }).parser({ abi });
 
+const fuseReadInDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseReadInDefinition,
 }).parser({ abi });
 
+const fuseWriteInDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseWriteInDefinition,
 }).parser({ abi });
 
+const fuseWriteOutDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "size", definition: types.UInt32 },
+    { name: "padding", definition: types.UInt32 },
+  ],
+} /*as const*/;
+
 const fuseWriteOutParser/*: TStructParser<TFuseWriteOutValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "size", definition: types.UInt32 },
-      { name: "padding", definition: types.UInt32 },
-    ],
-  },
+  definition: fuseWriteOutDefinition,
 }).parser({ abi });
 
+const fuseMkdirInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "mode", definition: types.UInt32 },
+    { name: "umask", definition: types.UInt32 },
+  ],
+} /*as const*/;
+
 const fuseMkdirInParser/*: TStructParser<TFuseMkdirInValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "mode", definition: types.UInt32 },
-      { name: "umask", definition: types.UInt32 },
-    ],
-  },
+  definition: fuseMkdirInDefinition,
 }).parser({ abi });
 
+const fuseMknodInDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseMknodInDefinition,
 }).parser({ abi });
 
+const fuseRenameInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "newdir", definition: types.UInt64 },
+  ],
+} /*as const*/;
+
 const fuseRenameInParser/*: TStructParser<TFuseRenameInValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "newdir", definition: types.UInt64 },
-    ],
-  },
+  definition: fuseRenameInDefinition,
 }).parser({ abi });
 
+const fuseRename2InDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "newdir", definition: types.UInt64 },
+    { name: "flags", definition: types.UInt32 },
+    { name: "padding", definition: types.UInt32 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseRename2InDefinition,
 }).parser({ abi });
 
+const fuseLinkInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "oldnodeid", definition: types.UInt64 },
+  ],
+} /*as const*/;
+
 const fuseLinkInParser/*: TStructParser<TFuseLinkInValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "oldnodeid", definition: types.UInt64 },
-    ],
-  },
+  definition: fuseLinkInDefinition,
 }).parser({ abi });
 
+const fuseLkInDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseLkInDefinition,
 }).parser({ abi });
 
+const fuseLkOutDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "lk", definition: fuseFileLockDefinition },
+  ],
+} /*as const*/;
+
 const fuseLkOutParser/*: TStructParser<TFuseLkOutValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "lk", definition: fuseFileLockDefinition },
-    ],
-  },
+  definition: fuseLkOutDefinition,
 }).parser({ abi });
 
+const fuseInterruptInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "unique", definition: types.UInt64 },
+  ],
+} /*as const*/;
+
 const fuseInterruptInParser/*: TStructParser<TFuseInterruptInValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "unique", definition: types.UInt64 },
-    ],
-  },
+  definition: fuseInterruptInDefinition,
 }).parser({ abi });
 
+const fuseBmapInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "block", definition: types.UInt64 },
+    { name: "blocksize", definition: types.UInt32 },
+    { name: "padding", definition: types.UInt32 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseBmapInDefinition,
 }).parser({ abi });
 
+const fuseBmapOutDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "block", definition: types.UInt64 },
+  ],
+} /*as const*/;
+
 const fuseBmapOutParser/*: TStructParser<TFuseBmapOutValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "block", definition: types.UInt64 },
-    ],
-  },
+  definition: fuseBmapOutDefinition,
 }).parser({ abi });
 
+const fuseIoctlInDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseIoctlInDefinition,
 }).parser({ abi });
 
+const fuseIoctlOutDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseIoctlOutDefinition,
 }).parser({ abi });
 
+const fusePollInDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fusePollInDefinition,
 }).parser({ abi });
 
+const fusePollOutDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "revents", definition: types.UInt32 },
+    { name: "padding", definition: types.UInt32 },
+  ],
+} /*as const*/;
+
 const fusePollOutParser/*: TStructParser<TFusePollOutValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "revents", definition: types.UInt32 },
-      { name: "padding", definition: types.UInt32 },
-    ],
-  },
+  definition: fusePollOutDefinition,
 }).parser({ abi });
 
+const fuseFallocateInDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseFallocateInDefinition,
 }).parser({ abi });
 
+const fuseForgetInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "nlookup", definition: types.UInt64 },
+  ],
+} /*as const*/;
+
 const fuseForgetInParser/*: TStructParser<TFuseForgetInValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "nlookup", definition: types.UInt64 },
-    ],
-  },
+  definition: fuseForgetInDefinition,
 }).parser({ abi });
 
+const fuseBatchForgetInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "count", definition: types.UInt32 },
+    { name: "dummy", definition: types.UInt32 },
+  ],
+} /*as const*/;
+
 const fuseBatchForgetInParser/*: TStructParser<TFuseBatchForgetInValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "count", definition: types.UInt32 },
-      { name: "dummy", definition: types.UInt32 },
-    ],
-  },
+  definition: fuseBatchForgetInDefinition,
 }).parser({ abi });
 
+const fuseForgetOneDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "nodeid", definition: types.UInt64 },
+    { name: "nlookup", definition: types.UInt64 },
+  ],
+} /*as const*/;
+
 const fuseForgetOneParser/*: TStructParser<TFuseForgetOneValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "nodeid", definition: types.UInt64 },
-      { name: "nlookup", definition: types.UInt64 },
-    ],
-  },
+  definition: fuseForgetOneDefinition,
 }).parser({ abi });
 
+const fuseAccessInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "mask", definition: types.UInt32 },
+    { name: "padding", definition: types.UInt32 },
+  ],
+} /*as const*/;
+
 const fuseAccessInParser/*: TStructParser<TFuseAccessInValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "mask", definition: types.UInt32 },
-      { name: "padding", definition: types.UInt32 },
-    ],
-  },
+  definition: fuseAccessInDefinition,
 }).parser({ abi });
 
+const fuseFsyncInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "fh", definition: types.UInt64 },
+    { name: "fsync_flags", definition: types.UInt32 },
+    { name: "padding", definition: types.UInt32 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseFsyncInDefinition,
 }).parser({ abi });
 
+const fuseSetxattrInDefinition = {
+  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 },
+  ],
+} /*as const*/;
+
 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 },
-    ],
-  },
+  definition: fuseSetxattrInDefinition,
 }).parser({ abi });
 
+const fuseInitInDefinition = {
+  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) },
+  ],
+} /*as const*/;
+
 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) },
-    ],
-  },
+  definition: fuseInitInDefinition,
 }).parser({ abi });
 
+const fuseInitOutDefinition = {
+  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) },
+  ],
+} /*as const*/;
+
 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) },
-    ],
-  },
+  definition: fuseInitOutDefinition,
 }).parser({ abi });
 
+const fuseStatfsOutDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "st", definition: fuseKstatfsDefinition },
+  ],
+} /*as const*/;
+
 const fuseStatfsOutParser/*: TStructParser<TFuseStatfsOutValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "st", definition: fuseKstatfsDefinition },
-    ],
-  },
+  definition: fuseStatfsOutDefinition,
 }).parser({ abi });
 
+const fuseLseekInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "fh", definition: types.UInt64 },
+    { name: "offset", definition: types.UInt64 },
+    { name: "whence", definition: types.UInt32 },
+    { name: "padding", definition: types.UInt32 },
+  ],
+} /*as const*/;
+
 const fuseLseekInParser/*: TStructParser<TFuseLseekInValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "fh", definition: types.UInt64 },
-      { name: "offset", definition: types.UInt64 },
-      { name: "whence", definition: types.UInt32 },
-      { name: "padding", definition: types.UInt32 },
-    ],
-  },
+  definition: fuseLseekInDefinition,
 }).parser({ abi });
 
+const fuseLseekOutDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "offset", definition: types.UInt64 },
+  ],
+} /*as const*/;
+
 const fuseLseekOutParser/*: TStructParser<TFuseLseekOutValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "offset", definition: types.UInt64 },
-    ],
-  },
+  definition: fuseLseekOutDefinition,
 }).parser({ abi });
 
+const fuseCopyFileRangeInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "fh_in", definition: types.UInt64 },
+    { name: "off_in", definition: types.UInt64 },
+    { name: "nodeid_out", definition: types.UInt64 },
+    { name: "fh_out", definition: types.UInt64 },
+    { name: "off_out", definition: types.UInt64 },
+    { name: "len", definition: types.UInt64 },
+    { name: "flags", definition: types.UInt64 },
+  ],
+} /*as const*/;
+
 const fuseCopyFileRangeInParser/*: TStructParser<TFuseCopyFileRangeInValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "fh_in", definition: types.UInt64 },
-      { name: "off_in", definition: types.UInt64 },
-      { name: "nodeid_out", definition: types.UInt64 },
-      { name: "fh_out", definition: types.UInt64 },
-      { name: "off_out", definition: types.UInt64 },
-      { name: "len", definition: types.UInt64 },
-      { name: "flags", definition: types.UInt64 },
-    ],
-  },
+  definition: fuseCopyFileRangeInDefinition,
 }).parser({ abi });
 
+const fuseSetupmappingInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "fh", definition: types.UInt64 },
+    { name: "foffset", definition: types.UInt64 },
+    { name: "len", definition: types.UInt64 },
+    { name: "flags", definition: types.UInt64 },
+    { name: "moffset", definition: types.UInt64 },
+  ],
+} /*as const*/;
+
 const fuseSetupmappingInParser/*: TStructParser<TFuseSetupmappingInValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "fh", definition: types.UInt64 },
-      { name: "foffset", definition: types.UInt64 },
-      { name: "len", definition: types.UInt64 },
-      { name: "flags", definition: types.UInt64 },
-      { name: "moffset", definition: types.UInt64 },
-    ],
-  },
+  definition: fuseSetupmappingInDefinition,
 }).parser({ abi });
 
+const fuseRemovemappingInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "count", definition: types.UInt32 },
+  ],
+} /*as const*/;
+
 const fuseRemovemappingInParser/*: TStructParser<TFuseRemovemappingInValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "count", definition: types.UInt32 },
-    ],
-  },
+  definition: fuseRemovemappingInDefinition,
 }).parser({ abi });
 
+const fuseRemovemappingOneDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "moffset", definition: types.UInt64 },
+    { name: "len", definition: types.UInt64 },
+  ],
+} /*as const*/;
+
 const fuseRemovemappingOneParser/*: TStructParser<TFuseRemovemappingOneValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "moffset", definition: types.UInt64 },
-      { name: "len", definition: types.UInt64 },
-    ],
-  },
+  definition: fuseRemovemappingOneDefinition,
 }).parser({ abi });
 
+const fuseSyncfsInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "padding", definition: types.UInt64 },
+  ],
+} /*as const*/;
+
 const fuseSyncfsInParser/*: TStructParser<TFuseSyncfsInValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "padding", definition: types.UInt64 },
-    ],
-  },
+  definition: fuseSyncfsInDefinition,
 }).parser({ abi });
 
 const fuseSxTimeDefinition = {
@@ -1107,34 +1201,38 @@ const fuseStatxDefinition = {
   ],
 } /*as const*/;
 
+const fuseStatxInDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "getattr_flags", definition: types.UInt32 },
+    { name: "reserved", definition: types.UInt32 },
+    { name: "fh", definition: types.UInt64 },
+    { name: "sx_flags", definition: types.UInt32 },
+    { name: "sx_mask", definition: types.UInt32 },
+  ],
+} /*as const*/;
+
 const fuseStatxInParser/*: TStructParser<TFuseStatxInValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "getattr_flags", definition: types.UInt32 },
-      { name: "reserved", definition: types.UInt32 },
-      { name: "fh", definition: types.UInt64 },
-      { name: "sx_flags", definition: types.UInt32 },
-      { name: "sx_mask", definition: types.UInt32 },
-    ],
-  },
+  definition: fuseStatxInDefinition,
 }).parser({ abi });
 
+const fuseStatxOutDefinition = {
+  type: "struct",
+  packed: false,
+  fixedAbi: {},
+  fields: [
+    { name: "attr_valid", definition: types.UInt64 },
+    { name: "attr_valid_nsec", definition: types.UInt32 },
+    { name: "flags", definition: types.UInt32 },
+    { name: "spare", definition: uint64Array(2) },
+    { name: "stat", definition: fuseStatxDefinition },
+  ],
+} /*as const*/;
+
 const fuseStatxOutParser/*: TStructParser<TFuseStatxOutValue>*/ = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "attr_valid", definition: types.UInt64 },
-      { name: "attr_valid_nsec", definition: types.UInt32 },
-      { name: "flags", definition: types.UInt32 },
-      { name: "spare", definition: uint64Array(2) },
-      { name: "stat", definition: fuseStatxDefinition },
-    ],
-  },
+  definition: fuseStatxOutDefinition,
 }).parser({ abi });
 
 const textEncoder = new TextEncoder();
@@ -1154,20 +1252,39 @@ const decodeCString = (data/*: Uint8Array*/) => {
   return textDecoder.decode(slice);
 };
 
-const decodeCStringPair = (data/*: Uint8Array*/) => {
+/*type TDecodeCStringPairResult = {
+  error: Error;
+  first: undefined;
+  second: undefined;
+} | {
+  error: undefined;
+  first: string;
+  second: string;
+};*/
+
+const decodeCStringPair = (data/*: Uint8Array*/)/*: TDecodeCStringPairResult*/ => {
   const firstTerminator = data.indexOf(0);
   if (firstTerminator === -1) {
-    throw Error("expected first nul-terminated string");
+    return {
+      error: Error("expected first nul-terminated string"),
+      first: undefined,
+      second: undefined,
+    };
   }
 
   const secondStart = firstTerminator + 1;
   const secondTerminatorOffset = data.subarray(secondStart).indexOf(0);
   if (secondTerminatorOffset === -1) {
-    throw Error("expected second nul-terminated string");
+    return {
+      error: Error("expected second nul-terminated string"),
+      first: undefined,
+      second: undefined,
+    };
   }
 
   const secondTerminator = secondStart + secondTerminatorOffset;
   return {
+    error: undefined,
     first: textDecoder.decode(data.subarray(0, firstTerminator)),
     second: textDecoder.decode(data.subarray(secondStart, secondTerminator)),
   };
@@ -1176,6 +1293,7 @@ const decodeCStringPair = (data/*: Uint8Array*/) => {
 export {
 
   decodeCString,
+
   decodeCStringPair,
   toCString,
 
@@ -1230,6 +1348,58 @@ export {
   fuseSyncfsInParser,
   fuseStatxInParser,
   fuseStatxOutParser,
+
+  fuseStatxDefinition,
+  fuseSxTimeDefinition,
+  fuseInHeaderDefinition,
+  fuseOutHeaderDefinition,
+  fuseEntryOutDefinition,
+  fuseGetattrInDefinition,
+  fuseAttrOutDefinition,
+  fuseSetattrInDefinition,
+  fuseOpenInDefinition,
+  fuseGetxattrInDefinition,
+  fuseGetxattrOutDefinition,
+  fuseCreateInDefinition,
+  fuseOpenOutDefinition,
+  fuseReleaseInDefinition,
+  fuseFlushInDefinition,
+  fuseReadInDefinition,
+  fuseWriteInDefinition,
+  fuseWriteOutDefinition,
+  fuseMkdirInDefinition,
+  fuseMknodInDefinition,
+  fuseRenameInDefinition,
+  fuseRename2InDefinition,
+  fuseLinkInDefinition,
+  fuseLkInDefinition,
+  fuseLkOutDefinition,
+  fuseInterruptInDefinition,
+  fuseBmapInDefinition,
+  fuseBmapOutDefinition,
+  fuseIoctlInDefinition,
+  fuseIoctlOutDefinition,
+  fusePollInDefinition,
+  fusePollOutDefinition,
+  fuseFallocateInDefinition,
+  fuseForgetInDefinition,
+  fuseBatchForgetInDefinition,
+  fuseForgetOneDefinition,
+  fuseAccessInDefinition,
+  fuseFsyncInDefinition,
+  fuseSetxattrInDefinition,
+  fuseInitInDefinition,
+  fuseInitOutDefinition,
+  fuseStatfsOutDefinition,
+  fuseLseekInDefinition,
+  fuseLseekOutDefinition,
+  fuseCopyFileRangeInDefinition,
+  fuseSetupmappingInDefinition,
+  fuseRemovemappingInDefinition,
+  fuseRemovemappingOneDefinition,
+  fuseSyncfsInDefinition,
+  fuseStatxInDefinition,
+  fuseStatxOutDefinition,
 };
 
 /*export type {