spacetimedb 2.3.0 → 2.4.1

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>;
@@ -1330,8 +1590,144 @@ export declare const RawModuleDef: import("../..").SumBuilder<{
                         sourceName: import("../..").StringBuilder;
                         canonicalName: import("../..").StringBuilder;
                     }>;
-                }>>;
-            }>;
+                }>>;
+            }>;
+            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;
+            }>>;
+            readonly ViewPrimaryKeys: import("../..").ArrayBuilder<import("../..").ProductBuilder<{
+                viewSourceName: import("../..").StringBuilder;
+                columns: import("../..").ArrayBuilder<import("../..").StringBuilder>;
+            }>>;
         }>>;
     }>;
 }>;
@@ -1614,6 +2010,142 @@ 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;
+        }>>;
+        readonly ViewPrimaryKeys: import("../..").ArrayBuilder<import("../..").ProductBuilder<{
+            viewSourceName: import("../..").StringBuilder;
+            columns: import("../..").ArrayBuilder<import("../..").StringBuilder>;
+        }>>;
     }>>;
 }>;
 export type RawModuleDefV10 = __Infer<typeof RawModuleDefV10>;
@@ -1894,6 +2426,142 @@ 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;
+    }>>;
+    readonly ViewPrimaryKeys: import("../..").ArrayBuilder<import("../..").ProductBuilder<{
+        viewSourceName: import("../..").StringBuilder;
+        columns: import("../..").ArrayBuilder<import("../..").StringBuilder>;
+    }>>;
 }>;
 export type RawModuleDefV10Section = __Infer<typeof RawModuleDefV10Section>;
 export declare const RawModuleDefV8: import("../..").ProductBuilder<{
@@ -2625,6 +3293,11 @@ export declare const RawViewDefV9: import("../..").ProductBuilder<{
     readonly returnType: __TypeBuilder<__AlgebraicTypeType, __AlgebraicTypeType>;
 }>;
 export type RawViewDefV9 = __Infer<typeof RawViewDefV9>;
+export declare const RawViewPrimaryKeyDefV10: import("../..").ProductBuilder<{
+    viewSourceName: import("../..").StringBuilder;
+    columns: import("../..").ArrayBuilder<import("../..").StringBuilder>;
+}>;
+export type RawViewPrimaryKeyDefV10 = __Infer<typeof RawViewPrimaryKeyDefV10>;
 export declare const ReducerDef: import("../..").ProductBuilder<{
     name: import("../..").StringBuilder;
     readonly args: import("../..").ArrayBuilder<import("../..").ProductBuilder<{