spacetimedb 2.2.0 → 2.4.0

package/dist/lib/autogen/types.d.ts

@@ -596,6 +596,132 @@ export declare const Lifecycle: import("../..").SumBuilder<{
     };
 }>;
 export type Lifecycle = __Infer<typeof Lifecycle>;
+export declare const MethodOrAny: import("../..").SumBuilder<{
+    Any: {
+        readonly type: {};
+        readonly algebraicType: {
+            tag: "Product";
+            value: {
+                elements: [];
+            };
+        };
+        optional(): import("../..").OptionBuilder</*elided*/ any>;
+        serialize(writer: import("../binary_writer").default, value: {}): void;
+        deserialize(reader: import("../binary_reader").default): {};
+    };
+    readonly Method: import("../..").SumBuilder<{
+        Get: {
+            readonly type: {};
+            readonly algebraicType: {
+                tag: "Product";
+                value: {
+                    elements: [];
+                };
+            };
+            optional(): import("../..").OptionBuilder</*elided*/ any>;
+            serialize(writer: import("../binary_writer").default, value: {}): void;
+            deserialize(reader: import("../binary_reader").default): {};
+        };
+        Head: {
+            readonly type: {};
+            readonly algebraicType: {
+                tag: "Product";
+                value: {
+                    elements: [];
+                };
+            };
+            optional(): import("../..").OptionBuilder</*elided*/ any>;
+            serialize(writer: import("../binary_writer").default, value: {}): void;
+            deserialize(reader: import("../binary_reader").default): {};
+        };
+        Post: {
+            readonly type: {};
+            readonly algebraicType: {
+                tag: "Product";
+                value: {
+                    elements: [];
+                };
+            };
+            optional(): import("../..").OptionBuilder</*elided*/ any>;
+            serialize(writer: import("../binary_writer").default, value: {}): void;
+            deserialize(reader: import("../binary_reader").default): {};
+        };
+        Put: {
+            readonly type: {};
+            readonly algebraicType: {
+                tag: "Product";
+                value: {
+                    elements: [];
+                };
+            };
+            optional(): import("../..").OptionBuilder</*elided*/ any>;
+            serialize(writer: import("../binary_writer").default, value: {}): void;
+            deserialize(reader: import("../binary_reader").default): {};
+        };
+        Delete: {
+            readonly type: {};
+            readonly algebraicType: {
+                tag: "Product";
+                value: {
+                    elements: [];
+                };
+            };
+            optional(): import("../..").OptionBuilder</*elided*/ any>;
+            serialize(writer: import("../binary_writer").default, value: {}): void;
+            deserialize(reader: import("../binary_reader").default): {};
+        };
+        Connect: {
+            readonly type: {};
+            readonly algebraicType: {
+                tag: "Product";
+                value: {
+                    elements: [];
+                };
+            };
+            optional(): import("../..").OptionBuilder</*elided*/ any>;
+            serialize(writer: import("../binary_writer").default, value: {}): void;
+            deserialize(reader: import("../binary_reader").default): {};
+        };
+        Options: {
+            readonly type: {};
+            readonly algebraicType: {
+                tag: "Product";
+                value: {
+                    elements: [];
+                };
+            };
+            optional(): import("../..").OptionBuilder</*elided*/ any>;
+            serialize(writer: import("../binary_writer").default, value: {}): void;
+            deserialize(reader: import("../binary_reader").default): {};
+        };
+        Trace: {
+            readonly type: {};
+            readonly algebraicType: {
+                tag: "Product";
+                value: {
+                    elements: [];
+                };
+            };
+            optional(): import("../..").OptionBuilder</*elided*/ any>;
+            serialize(writer: import("../binary_writer").default, value: {}): void;
+            deserialize(reader: import("../binary_reader").default): {};
+        };
+        Patch: {
+            readonly type: {};
+            readonly algebraicType: {
+                tag: "Product";
+                value: {
+                    elements: [];
+                };
+            };
+            optional(): import("../..").OptionBuilder</*elided*/ any>;
+            serialize(writer: import("../binary_writer").default, value: {}): void;
+            deserialize(reader: import("../binary_reader").default): {};
+        };
+        Extension: import("../..").StringBuilder;
+    }>;
+}>;
+export type MethodOrAny = __Infer<typeof MethodOrAny>;
 export declare const MiscModuleExport: import("../..").SumBuilder<{
     readonly TypeAlias: import("../..").ProductBuilder<{
         name: import("../..").StringBuilder;
@@ -666,6 +792,140 @@ export declare const RawConstraintDefV9: import("../..").ProductBuilder<{
     }>;
 }>;
 export type RawConstraintDefV9 = __Infer<typeof RawConstraintDefV9>;
+export declare const RawHttpHandlerDefV10: import("../..").ProductBuilder<{
+    sourceName: import("../..").StringBuilder;
+}>;
+export type RawHttpHandlerDefV10 = __Infer<typeof RawHttpHandlerDefV10>;
+export declare const RawHttpRouteDefV10: import("../..").ProductBuilder<{
+    handlerFunction: import("../..").StringBuilder;
+    readonly method: import("../..").SumBuilder<{
+        Any: {
+            readonly type: {};
+            readonly algebraicType: {
+                tag: "Product";
+                value: {
+                    elements: [];
+                };
+            };
+            optional(): import("../..").OptionBuilder</*elided*/ any>;
+            serialize(writer: import("../binary_writer").default, value: {}): void;
+            deserialize(reader: import("../binary_reader").default): {};
+        };
+        readonly Method: import("../..").SumBuilder<{
+            Get: {
+                readonly type: {};
+                readonly algebraicType: {
+                    tag: "Product";
+                    value: {
+                        elements: [];
+                    };
+                };
+                optional(): import("../..").OptionBuilder</*elided*/ any>;
+                serialize(writer: import("../binary_writer").default, value: {}): void;
+                deserialize(reader: import("../binary_reader").default): {};
+            };
+            Head: {
+                readonly type: {};
+                readonly algebraicType: {
+                    tag: "Product";
+                    value: {
+                        elements: [];
+                    };
+                };
+                optional(): import("../..").OptionBuilder</*elided*/ any>;
+                serialize(writer: import("../binary_writer").default, value: {}): void;
+                deserialize(reader: import("../binary_reader").default): {};
+            };
+            Post: {
+                readonly type: {};
+                readonly algebraicType: {
+                    tag: "Product";
+                    value: {
+                        elements: [];
+                    };
+                };
+                optional(): import("../..").OptionBuilder</*elided*/ any>;
+                serialize(writer: import("../binary_writer").default, value: {}): void;
+                deserialize(reader: import("../binary_reader").default): {};
+            };
+            Put: {
+                readonly type: {};
+                readonly algebraicType: {
+                    tag: "Product";
+                    value: {
+                        elements: [];
+                    };
+                };
+                optional(): import("../..").OptionBuilder</*elided*/ any>;
+                serialize(writer: import("../binary_writer").default, value: {}): void;
+                deserialize(reader: import("../binary_reader").default): {};
+            };
+            Delete: {
+                readonly type: {};
+                readonly algebraicType: {
+                    tag: "Product";
+                    value: {
+                        elements: [];
+                    };
+                };
+                optional(): import("../..").OptionBuilder</*elided*/ any>;
+                serialize(writer: import("../binary_writer").default, value: {}): void;
+                deserialize(reader: import("../binary_reader").default): {};
+            };
+            Connect: {
+                readonly type: {};
+                readonly algebraicType: {
+                    tag: "Product";
+                    value: {
+                        elements: [];
+                    };
+                };
+                optional(): import("../..").OptionBuilder</*elided*/ any>;
+                serialize(writer: import("../binary_writer").default, value: {}): void;
+                deserialize(reader: import("../binary_reader").default): {};
+            };
+            Options: {
+                readonly type: {};
+                readonly algebraicType: {
+                    tag: "Product";
+                    value: {
+                        elements: [];
+                    };
+                };
+                optional(): import("../..").OptionBuilder</*elided*/ any>;
+                serialize(writer: import("../binary_writer").default, value: {}): void;
+                deserialize(reader: import("../binary_reader").default): {};
+            };
+            Trace: {
+                readonly type: {};
+                readonly algebraicType: {
+                    tag: "Product";
+                    value: {
+                        elements: [];
+                    };
+                };
+                optional(): import("../..").OptionBuilder</*elided*/ any>;
+                serialize(writer: import("../binary_writer").default, value: {}): void;
+                deserialize(reader: import("../binary_reader").default): {};
+            };
+            Patch: {
+                readonly type: {};
+                readonly algebraicType: {
+                    tag: "Product";
+                    value: {
+                        elements: [];
+                    };
+                };
+                optional(): import("../..").OptionBuilder</*elided*/ any>;
+                serialize(writer: import("../binary_writer").default, value: {}): void;
+                deserialize(reader: import("../binary_reader").default): {};
+            };
+            Extension: import("../..").StringBuilder;
+        }>;
+    }>;
+    path: import("../..").StringBuilder;
+}>;
+export type RawHttpRouteDefV10 = __Infer<typeof RawHttpRouteDefV10>;
 export declare const RawIndexAlgorithm: import("../..").SumBuilder<{
     BTree: import("../..").ArrayBuilder<import("../..").U16Builder>;
     Hash: import("../..").ArrayBuilder<import("../..").U16Builder>;
@@ -1332,25 +1592,157 @@ export declare const RawModuleDef: import("../..").SumBuilder<{
                     }>;
                 }>>;
             }>;
-        }>>;
-    }>;
-}>;
-export type RawModuleDef = __Infer<typeof RawModuleDef>;
-export declare const RawModuleDefV10: import("../..").ProductBuilder<{
-    readonly sections: import("../..").ArrayBuilder<import("../..").SumBuilder<{
-        readonly Typespace: import("../..").ProductBuilder<{
-            readonly types: import("../..").ArrayBuilder<__TypeBuilder<__AlgebraicTypeType, __AlgebraicTypeType>>;
-        }>;
-        readonly Types: import("../..").ArrayBuilder<import("../..").ProductBuilder<{
-            readonly sourceName: import("../..").ProductBuilder<{
-                scope: import("../..").ArrayBuilder<import("../..").StringBuilder>;
+            readonly HttpHandlers: import("../..").ArrayBuilder<import("../..").ProductBuilder<{
                 sourceName: import("../..").StringBuilder;
-            }>;
-            ty: import("../..").U32Builder;
-            customOrdering: import("../..").BoolBuilder;
-        }>>;
-        readonly Tables: import("../..").ArrayBuilder<import("../..").ProductBuilder<{
-            sourceName: import("../..").StringBuilder;
+            }>>;
+            readonly HttpRoutes: import("../..").ArrayBuilder<import("../..").ProductBuilder<{
+                handlerFunction: import("../..").StringBuilder;
+                readonly method: import("../..").SumBuilder<{
+                    Any: {
+                        readonly type: {};
+                        readonly algebraicType: {
+                            tag: "Product";
+                            value: {
+                                elements: [];
+                            };
+                        };
+                        optional(): import("../..").OptionBuilder</*elided*/ any>;
+                        serialize(writer: import("../binary_writer").default, value: {}): void;
+                        deserialize(reader: import("../binary_reader").default): {};
+                    };
+                    readonly Method: import("../..").SumBuilder<{
+                        Get: {
+                            readonly type: {};
+                            readonly algebraicType: {
+                                tag: "Product";
+                                value: {
+                                    elements: [];
+                                };
+                            };
+                            optional(): import("../..").OptionBuilder</*elided*/ any>;
+                            serialize(writer: import("../binary_writer").default, value: {}): void;
+                            deserialize(reader: import("../binary_reader").default): {};
+                        };
+                        Head: {
+                            readonly type: {};
+                            readonly algebraicType: {
+                                tag: "Product";
+                                value: {
+                                    elements: [];
+                                };
+                            };
+                            optional(): import("../..").OptionBuilder</*elided*/ any>;
+                            serialize(writer: import("../binary_writer").default, value: {}): void;
+                            deserialize(reader: import("../binary_reader").default): {};
+                        };
+                        Post: {
+                            readonly type: {};
+                            readonly algebraicType: {
+                                tag: "Product";
+                                value: {
+                                    elements: [];
+                                };
+                            };
+                            optional(): import("../..").OptionBuilder</*elided*/ any>;
+                            serialize(writer: import("../binary_writer").default, value: {}): void;
+                            deserialize(reader: import("../binary_reader").default): {};
+                        };
+                        Put: {
+                            readonly type: {};
+                            readonly algebraicType: {
+                                tag: "Product";
+                                value: {
+                                    elements: [];
+                                };
+                            };
+                            optional(): import("../..").OptionBuilder</*elided*/ any>;
+                            serialize(writer: import("../binary_writer").default, value: {}): void;
+                            deserialize(reader: import("../binary_reader").default): {};
+                        };
+                        Delete: {
+                            readonly type: {};
+                            readonly algebraicType: {
+                                tag: "Product";
+                                value: {
+                                    elements: [];
+                                };
+                            };
+                            optional(): import("../..").OptionBuilder</*elided*/ any>;
+                            serialize(writer: import("../binary_writer").default, value: {}): void;
+                            deserialize(reader: import("../binary_reader").default): {};
+                        };
+                        Connect: {
+                            readonly type: {};
+                            readonly algebraicType: {
+                                tag: "Product";
+                                value: {
+                                    elements: [];
+                                };
+                            };
+                            optional(): import("../..").OptionBuilder</*elided*/ any>;
+                            serialize(writer: import("../binary_writer").default, value: {}): void;
+                            deserialize(reader: import("../binary_reader").default): {};
+                        };
+                        Options: {
+                            readonly type: {};
+                            readonly algebraicType: {
+                                tag: "Product";
+                                value: {
+                                    elements: [];
+                                };
+                            };
+                            optional(): import("../..").OptionBuilder</*elided*/ any>;
+                            serialize(writer: import("../binary_writer").default, value: {}): void;
+                            deserialize(reader: import("../binary_reader").default): {};
+                        };
+                        Trace: {
+                            readonly type: {};
+                            readonly algebraicType: {
+                                tag: "Product";
+                                value: {
+                                    elements: [];
+                                };
+                            };
+                            optional(): import("../..").OptionBuilder</*elided*/ any>;
+                            serialize(writer: import("../binary_writer").default, value: {}): void;
+                            deserialize(reader: import("../binary_reader").default): {};
+                        };
+                        Patch: {
+                            readonly type: {};
+                            readonly algebraicType: {
+                                tag: "Product";
+                                value: {
+                                    elements: [];
+                                };
+                            };
+                            optional(): import("../..").OptionBuilder</*elided*/ any>;
+                            serialize(writer: import("../binary_writer").default, value: {}): void;
+                            deserialize(reader: import("../binary_reader").default): {};
+                        };
+                        Extension: import("../..").StringBuilder;
+                    }>;
+                }>;
+                path: import("../..").StringBuilder;
+            }>>;
+        }>>;
+    }>;
+}>;
+export type RawModuleDef = __Infer<typeof RawModuleDef>;
+export declare const RawModuleDefV10: import("../..").ProductBuilder<{
+    readonly sections: import("../..").ArrayBuilder<import("../..").SumBuilder<{
+        readonly Typespace: import("../..").ProductBuilder<{
+            readonly types: import("../..").ArrayBuilder<__TypeBuilder<__AlgebraicTypeType, __AlgebraicTypeType>>;
+        }>;
+        readonly Types: import("../..").ArrayBuilder<import("../..").ProductBuilder<{
+            readonly sourceName: import("../..").ProductBuilder<{
+                scope: import("../..").ArrayBuilder<import("../..").StringBuilder>;
+                sourceName: import("../..").StringBuilder;
+            }>;
+            ty: import("../..").U32Builder;
+            customOrdering: import("../..").BoolBuilder;
+        }>>;
+        readonly Tables: import("../..").ArrayBuilder<import("../..").ProductBuilder<{
+            sourceName: import("../..").StringBuilder;
             productTypeRef: import("../..").U32Builder;
             primaryKey: import("../..").ArrayBuilder<import("../..").U16Builder>;
             readonly indexes: import("../..").ArrayBuilder<import("../..").ProductBuilder<{
@@ -1614,6 +2006,138 @@ export declare const RawModuleDefV10: import("../..").ProductBuilder<{
                 }>;
             }>>;
         }>;
+        readonly HttpHandlers: import("../..").ArrayBuilder<import("../..").ProductBuilder<{
+            sourceName: import("../..").StringBuilder;
+        }>>;
+        readonly HttpRoutes: import("../..").ArrayBuilder<import("../..").ProductBuilder<{
+            handlerFunction: import("../..").StringBuilder;
+            readonly method: import("../..").SumBuilder<{
+                Any: {
+                    readonly type: {};
+                    readonly algebraicType: {
+                        tag: "Product";
+                        value: {
+                            elements: [];
+                        };
+                    };
+                    optional(): import("../..").OptionBuilder</*elided*/ any>;
+                    serialize(writer: import("../binary_writer").default, value: {}): void;
+                    deserialize(reader: import("../binary_reader").default): {};
+                };
+                readonly Method: import("../..").SumBuilder<{
+                    Get: {
+                        readonly type: {};
+                        readonly algebraicType: {
+                            tag: "Product";
+                            value: {
+                                elements: [];
+                            };
+                        };
+                        optional(): import("../..").OptionBuilder</*elided*/ any>;
+                        serialize(writer: import("../binary_writer").default, value: {}): void;
+                        deserialize(reader: import("../binary_reader").default): {};
+                    };
+                    Head: {
+                        readonly type: {};
+                        readonly algebraicType: {
+                            tag: "Product";
+                            value: {
+                                elements: [];
+                            };
+                        };
+                        optional(): import("../..").OptionBuilder</*elided*/ any>;
+                        serialize(writer: import("../binary_writer").default, value: {}): void;
+                        deserialize(reader: import("../binary_reader").default): {};
+                    };
+                    Post: {
+                        readonly type: {};
+                        readonly algebraicType: {
+                            tag: "Product";
+                            value: {
+                                elements: [];
+                            };
+                        };
+                        optional(): import("../..").OptionBuilder</*elided*/ any>;
+                        serialize(writer: import("../binary_writer").default, value: {}): void;
+                        deserialize(reader: import("../binary_reader").default): {};
+                    };
+                    Put: {
+                        readonly type: {};
+                        readonly algebraicType: {
+                            tag: "Product";
+                            value: {
+                                elements: [];
+                            };
+                        };
+                        optional(): import("../..").OptionBuilder</*elided*/ any>;
+                        serialize(writer: import("../binary_writer").default, value: {}): void;
+                        deserialize(reader: import("../binary_reader").default): {};
+                    };
+                    Delete: {
+                        readonly type: {};
+                        readonly algebraicType: {
+                            tag: "Product";
+                            value: {
+                                elements: [];
+                            };
+                        };
+                        optional(): import("../..").OptionBuilder</*elided*/ any>;
+                        serialize(writer: import("../binary_writer").default, value: {}): void;
+                        deserialize(reader: import("../binary_reader").default): {};
+                    };
+                    Connect: {
+                        readonly type: {};
+                        readonly algebraicType: {
+                            tag: "Product";
+                            value: {
+                                elements: [];
+                            };
+                        };
+                        optional(): import("../..").OptionBuilder</*elided*/ any>;
+                        serialize(writer: import("../binary_writer").default, value: {}): void;
+                        deserialize(reader: import("../binary_reader").default): {};
+                    };
+                    Options: {
+                        readonly type: {};
+                        readonly algebraicType: {
+                            tag: "Product";
+                            value: {
+                                elements: [];
+                            };
+                        };
+                        optional(): import("../..").OptionBuilder</*elided*/ any>;
+                        serialize(writer: import("../binary_writer").default, value: {}): void;
+                        deserialize(reader: import("../binary_reader").default): {};
+                    };
+                    Trace: {
+                        readonly type: {};
+                        readonly algebraicType: {
+                            tag: "Product";
+                            value: {
+                                elements: [];
+                            };
+                        };
+                        optional(): import("../..").OptionBuilder</*elided*/ any>;
+                        serialize(writer: import("../binary_writer").default, value: {}): void;
+                        deserialize(reader: import("../binary_reader").default): {};
+                    };
+                    Patch: {
+                        readonly type: {};
+                        readonly algebraicType: {
+                            tag: "Product";
+                            value: {
+                                elements: [];
+                            };
+                        };
+                        optional(): import("../..").OptionBuilder</*elided*/ any>;
+                        serialize(writer: import("../binary_writer").default, value: {}): void;
+                        deserialize(reader: import("../binary_reader").default): {};
+                    };
+                    Extension: import("../..").StringBuilder;
+                }>;
+            }>;
+            path: import("../..").StringBuilder;
+        }>>;
     }>>;
 }>;
 export type RawModuleDefV10 = __Infer<typeof RawModuleDefV10>;
@@ -1894,6 +2418,138 @@ export declare const RawModuleDefV10Section: import("../..").SumBuilder<{
             }>;
         }>>;
     }>;
+    readonly HttpHandlers: import("../..").ArrayBuilder<import("../..").ProductBuilder<{
+        sourceName: import("../..").StringBuilder;
+    }>>;
+    readonly HttpRoutes: import("../..").ArrayBuilder<import("../..").ProductBuilder<{
+        handlerFunction: import("../..").StringBuilder;
+        readonly method: import("../..").SumBuilder<{
+            Any: {
+                readonly type: {};
+                readonly algebraicType: {
+                    tag: "Product";
+                    value: {
+                        elements: [];
+                    };
+                };
+                optional(): import("../..").OptionBuilder</*elided*/ any>;
+                serialize(writer: import("../binary_writer").default, value: {}): void;
+                deserialize(reader: import("../binary_reader").default): {};
+            };
+            readonly Method: import("../..").SumBuilder<{
+                Get: {
+                    readonly type: {};
+                    readonly algebraicType: {
+                        tag: "Product";
+                        value: {
+                            elements: [];
+                        };
+                    };
+                    optional(): import("../..").OptionBuilder</*elided*/ any>;
+                    serialize(writer: import("../binary_writer").default, value: {}): void;
+                    deserialize(reader: import("../binary_reader").default): {};
+                };
+                Head: {
+                    readonly type: {};
+                    readonly algebraicType: {
+                        tag: "Product";
+                        value: {
+                            elements: [];
+                        };
+                    };
+                    optional(): import("../..").OptionBuilder</*elided*/ any>;
+                    serialize(writer: import("../binary_writer").default, value: {}): void;
+                    deserialize(reader: import("../binary_reader").default): {};
+                };
+                Post: {
+                    readonly type: {};
+                    readonly algebraicType: {
+                        tag: "Product";
+                        value: {
+                            elements: [];
+                        };
+                    };
+                    optional(): import("../..").OptionBuilder</*elided*/ any>;
+                    serialize(writer: import("../binary_writer").default, value: {}): void;
+                    deserialize(reader: import("../binary_reader").default): {};
+                };
+                Put: {
+                    readonly type: {};
+                    readonly algebraicType: {
+                        tag: "Product";
+                        value: {
+                            elements: [];
+                        };
+                    };
+                    optional(): import("../..").OptionBuilder</*elided*/ any>;
+                    serialize(writer: import("../binary_writer").default, value: {}): void;
+                    deserialize(reader: import("../binary_reader").default): {};
+                };
+                Delete: {
+                    readonly type: {};
+                    readonly algebraicType: {
+                        tag: "Product";
+                        value: {
+                            elements: [];
+                        };
+                    };
+                    optional(): import("../..").OptionBuilder</*elided*/ any>;
+                    serialize(writer: import("../binary_writer").default, value: {}): void;
+                    deserialize(reader: import("../binary_reader").default): {};
+                };
+                Connect: {
+                    readonly type: {};
+                    readonly algebraicType: {
+                        tag: "Product";
+                        value: {
+                            elements: [];
+                        };
+                    };
+                    optional(): import("../..").OptionBuilder</*elided*/ any>;
+                    serialize(writer: import("../binary_writer").default, value: {}): void;
+                    deserialize(reader: import("../binary_reader").default): {};
+                };
+                Options: {
+                    readonly type: {};
+                    readonly algebraicType: {
+                        tag: "Product";
+                        value: {
+                            elements: [];
+                        };
+                    };
+                    optional(): import("../..").OptionBuilder</*elided*/ any>;
+                    serialize(writer: import("../binary_writer").default, value: {}): void;
+                    deserialize(reader: import("../binary_reader").default): {};
+                };
+                Trace: {
+                    readonly type: {};
+                    readonly algebraicType: {
+                        tag: "Product";
+                        value: {
+                            elements: [];
+                        };
+                    };
+                    optional(): import("../..").OptionBuilder</*elided*/ any>;
+                    serialize(writer: import("../binary_writer").default, value: {}): void;
+                    deserialize(reader: import("../binary_reader").default): {};
+                };
+                Patch: {
+                    readonly type: {};
+                    readonly algebraicType: {
+                        tag: "Product";
+                        value: {
+                            elements: [];
+                        };
+                    };
+                    optional(): import("../..").OptionBuilder</*elided*/ any>;
+                    serialize(writer: import("../binary_writer").default, value: {}): void;
+                    deserialize(reader: import("../binary_reader").default): {};
+                };
+                Extension: import("../..").StringBuilder;
+            }>;
+        }>;
+        path: import("../..").StringBuilder;
+    }>>;
 }>;
 export type RawModuleDefV10Section = __Infer<typeof RawModuleDefV10Section>;
 export declare const RawModuleDefV8: import("../..").ProductBuilder<{