npm - spacetimedb - Versions diffs - 2.3.0 → 2.4.0 - Mend

spacetimedb 2.3.0 → 2.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (59) hide show

package/LICENSE.txt +2 -2
package/dist/index.browser.mjs +50 -4
package/dist/index.browser.mjs.map +1 -1
package/dist/index.cjs +50 -4
package/dist/index.cjs.map +1 -1
package/dist/index.mjs +50 -4
package/dist/index.mjs.map +1 -1
package/dist/lib/autogen/types.d.ts +674 -18
package/dist/lib/autogen/types.d.ts.map +1 -1
package/dist/lib/schema.d.ts.map +1 -1
package/dist/min/index.browser.mjs +1 -1
package/dist/min/index.browser.mjs.map +1 -1
package/dist/min/sdk/index.browser.mjs +1 -1
package/dist/min/sdk/index.browser.mjs.map +1 -1
package/dist/sdk/decompress.d.ts.map +1 -1
package/dist/sdk/index.browser.mjs +50 -4
package/dist/sdk/index.browser.mjs.map +1 -1
package/dist/sdk/index.cjs +50 -4
package/dist/sdk/index.cjs.map +1 -1
package/dist/sdk/index.mjs +50 -4
package/dist/sdk/index.mjs.map +1 -1
package/dist/server/http.d.ts +1 -2
package/dist/server/http.d.ts.map +1 -1
package/dist/server/http.test-d.d.ts +2 -0
package/dist/server/http.test-d.d.ts.map +1 -0
package/dist/server/http_handlers.d.ts +82 -0
package/dist/server/http_handlers.d.ts.map +1 -0
package/dist/server/http_internal.d.ts +1 -32
package/dist/server/http_internal.d.ts.map +1 -1
package/dist/server/http_shared.d.ts +44 -0
package/dist/server/http_shared.d.ts.map +1 -0
package/dist/server/index.d.ts +2 -0
package/dist/server/index.d.ts.map +1 -1
package/dist/server/index.mjs +582 -134
package/dist/server/index.mjs.map +1 -1
package/dist/server/runtime.d.ts +1 -0
package/dist/server/runtime.d.ts.map +1 -1
package/dist/server/schema.d.ts +16 -1
package/dist/server/schema.d.ts.map +1 -1
package/dist/server/views.d.ts.map +1 -1
package/package.json +1 -1
package/src/lib/autogen/types.ts +29 -0
package/src/lib/schema.ts +14 -0
package/src/sdk/decompress.ts +19 -4
package/src/sdk/logger.ts +1 -1
package/src/server/http.test-d.ts +80 -0
package/src/server/http.ts +14 -2
package/src/server/http_handlers.ts +413 -0
package/src/server/http_internal.ts +15 -142
package/src/server/http_shared.ts +186 -0
package/src/server/index.ts +11 -0
package/src/server/procedures.ts +8 -30
package/src/server/runtime.ts +137 -1
package/src/server/schema.ts +71 -2
package/src/server/sys.d.ts +7 -0
package/src/server/views.ts +1 -0
package/dist/lib/http_types.d.ts +0 -2
package/dist/lib/http_types.d.ts.map +0 -1
package/src/lib/http_types.ts +0 -8

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

@@ -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<{