@alloy-js/go 0.3.0-dev.3 → 0.3.0

package/docs/api/variables/std.md

@@ -0,0 +1,2463 @@
+# std
+
+```ts
+std: {
+    io: import("../create-module.js").LibraryFrom<{
+        kind: "package";
+        members: {
+            fs: {
+                kind: "package";
+                members: {
+                    ErrInvalid: {
+                        kind: "var";
+                    };
+                    ErrPermission: {
+                        kind: "var";
+                    };
+                    ErrExist: {
+                        kind: "var";
+                    };
+                    ErrNotExist: {
+                        kind: "var";
+                    };
+                    ErrClosed: {
+                        kind: "var";
+                    };
+                    SkipAll: {
+                        kind: "var";
+                    };
+                    SkipDir: {
+                        kind: "var";
+                    };
+                    FormatDirEntry: {
+                        kind: "function";
+                    };
+                    FormatFileInfo: {
+                        kind: "function";
+                    };
+                    Glob: {
+                        kind: "function";
+                    };
+                    ReadFile: {
+                        kind: "function";
+                    };
+                    ReadLink: {
+                        kind: "function";
+                    };
+                    ValidPath: {
+                        kind: "function";
+                    };
+                    WalkDir: {
+                        kind: "function";
+                    };
+                    DirEntry: {
+                        kind: "interface";
+                        members: {
+                            Name: {
+                                kind: "field";
+                            };
+                            IsDir: {
+                                kind: "field";
+                            };
+                            Type: {
+                                kind: "field";
+                            };
+                            Info: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    FileInfoToDirEntry: {
+                        kind: "function";
+                    };
+                    ReadDir: {
+                        kind: "function";
+                    };
+                    FS: {
+                        kind: "interface";
+                        members: {
+                            Open: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    Sub: {
+                        kind: "function";
+                    };
+                    File: {
+                        kind: "interface";
+                        members: {
+                            Stat: {
+                                kind: "field";
+                            };
+                            Read: {
+                                kind: "field";
+                            };
+                            Close: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    FileInfo: {
+                        kind: "interface";
+                        members: {
+                            Name: {
+                                kind: "field";
+                            };
+                            Size: {
+                                kind: "field";
+                            };
+                            Mode: {
+                                kind: "field";
+                            };
+                            ModTime: {
+                                kind: "field";
+                            };
+                            IsDir: {
+                                kind: "field";
+                            };
+                            Sys: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    Lstat: {
+                        kind: "function";
+                    };
+                    Stat: {
+                        kind: "function";
+                    };
+                    FileMode: {
+                        kind: "type";
+                        members: {
+                            IsDir: {
+                                kind: "method";
+                            };
+                            IsRegular: {
+                                kind: "method";
+                            };
+                            Perm: {
+                                kind: "method";
+                            };
+                            String: {
+                                kind: "method";
+                            };
+                            Type: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    GlobFS: {
+                        kind: "interface";
+                        members: {
+                            FS: {
+                                kind: "embed";
+                                type: () => any;
+                            };
+                            Glob: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    PathError: {
+                        kind: "struct";
+                        members: {
+                            Op: {
+                                kind: "field";
+                            };
+                            Path: {
+                                kind: "field";
+                            };
+                            Err: {
+                                kind: "field";
+                            };
+                            Error: {
+                                kind: "method";
+                            };
+                            Timeout: {
+                                kind: "method";
+                            };
+                            Unwrap: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    ReadDirFS: {
+                        kind: "interface";
+                        members: {
+                            FS: {
+                                kind: "embed";
+                                type: () => any;
+                            };
+                            ReadDir: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    ReadDirFile: {
+                        kind: "interface";
+                        members: {
+                            File: {
+                                kind: "embed";
+                                type: () => any;
+                            };
+                            ReadDir: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    ReadFileFS: {
+                        kind: "interface";
+                        members: {
+                            FS: {
+                                kind: "embed";
+                                type: () => any;
+                            };
+                            ReadFile: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    ReadLinkFS: {
+                        kind: "interface";
+                        members: {
+                            FS: {
+                                kind: "embed";
+                                type: () => any;
+                            };
+                            ReadLink: {
+                                kind: "field";
+                            };
+                            Lstat: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    StatFS: {
+                        kind: "interface";
+                        members: {
+                            FS: {
+                                kind: "embed";
+                                type: () => any;
+                            };
+                            Stat: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    SubFS: {
+                        kind: "interface";
+                        members: {
+                            FS: {
+                                kind: "embed";
+                                type: () => any;
+                            };
+                            Sub: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    WalkDirFunc: {
+                        kind: "function";
+                    };
+                };
+            };
+            SeekStart: {
+                kind: "var";
+            };
+            SeekCurrent: {
+                kind: "var";
+            };
+            SeekEnd: {
+                kind: "var";
+            };
+            EOF: {
+                kind: "var";
+            };
+            ErrClosedPipe: {
+                kind: "var";
+            };
+            ErrNoProgress: {
+                kind: "var";
+            };
+            ErrShortBuffer: {
+                kind: "var";
+            };
+            ErrShortWrite: {
+                kind: "var";
+            };
+            ErrUnexpectedEOF: {
+                kind: "var";
+            };
+            Copy: {
+                kind: "function";
+            };
+            CopyBuffer: {
+                kind: "function";
+            };
+            CopyN: {
+                kind: "function";
+            };
+            Pipe: {
+                kind: "function";
+            };
+            ReadAll: {
+                kind: "function";
+            };
+            ReadAtLeast: {
+                kind: "function";
+            };
+            ReadFull: {
+                kind: "function";
+            };
+            WriteString: {
+                kind: "function";
+            };
+            ByteReader: {
+                kind: "interface";
+                members: {
+                    ReadByte: {
+                        kind: "field";
+                    };
+                };
+            };
+            ByteScanner: {
+                kind: "interface";
+                members: {
+                    ByteReader: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                    UnreadByte: {
+                        kind: "field";
+                    };
+                };
+            };
+            ByteWriter: {
+                kind: "interface";
+                members: {
+                    WriteByte: {
+                        kind: "field";
+                    };
+                };
+            };
+            Closer: {
+                kind: "interface";
+                members: {
+                    Close: {
+                        kind: "field";
+                    };
+                };
+            };
+            LimitedReader: {
+                kind: "struct";
+                members: {
+                    R: {
+                        kind: "field";
+                    };
+                    N: {
+                        kind: "field";
+                    };
+                    Read: {
+                        kind: "method";
+                    };
+                };
+            };
+            OffsetWriter: {
+                kind: "struct";
+                members: {
+                    Seek: {
+                        kind: "method";
+                    };
+                    Write: {
+                        kind: "method";
+                    };
+                    WriteAt: {
+                        kind: "method";
+                    };
+                };
+            };
+            NewOffsetWriter: {
+                kind: "function";
+            };
+            PipeReader: {
+                kind: "struct";
+                members: {
+                    Close: {
+                        kind: "method";
+                    };
+                    CloseWithError: {
+                        kind: "method";
+                    };
+                    Read: {
+                        kind: "method";
+                    };
+                };
+            };
+            PipeWriter: {
+                kind: "struct";
+                members: {
+                    Close: {
+                        kind: "method";
+                    };
+                    CloseWithError: {
+                        kind: "method";
+                    };
+                    Write: {
+                        kind: "method";
+                    };
+                };
+            };
+            ReadCloser: {
+                kind: "interface";
+                members: {
+                    Reader: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                    Closer: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                };
+            };
+            NopCloser: {
+                kind: "function";
+            };
+            ReadSeekCloser: {
+                kind: "interface";
+                members: {
+                    Reader: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                    Seeker: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                    Closer: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                };
+            };
+            ReadSeeker: {
+                kind: "interface";
+                members: {
+                    Reader: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                    Seeker: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                };
+            };
+            ReadWriteCloser: {
+                kind: "interface";
+                members: {
+                    Reader: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                    Writer: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                    Closer: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                };
+            };
+            ReadWriteSeeker: {
+                kind: "interface";
+                members: {
+                    Reader: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                    Writer: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                    Seeker: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                };
+            };
+            ReadWriter: {
+                kind: "interface";
+                members: {
+                    Reader: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                    Writer: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                };
+            };
+            Reader: {
+                kind: "interface";
+                members: {
+                    Read: {
+                        kind: "field";
+                    };
+                };
+            };
+            LimitReader: {
+                kind: "function";
+            };
+            MultiReader: {
+                kind: "function";
+            };
+            TeeReader: {
+                kind: "function";
+            };
+            ReaderAt: {
+                kind: "interface";
+                members: {
+                    ReadAt: {
+                        kind: "field";
+                    };
+                };
+            };
+            ReaderFrom: {
+                kind: "interface";
+                members: {
+                    ReadFrom: {
+                        kind: "field";
+                    };
+                };
+            };
+            RuneReader: {
+                kind: "interface";
+                members: {
+                    ReadRune: {
+                        kind: "field";
+                    };
+                };
+            };
+            RuneScanner: {
+                kind: "interface";
+                members: {
+                    RuneReader: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                    UnreadRune: {
+                        kind: "field";
+                    };
+                };
+            };
+            SectionReader: {
+                kind: "struct";
+                members: {
+                    Outer: {
+                        kind: "method";
+                    };
+                    Read: {
+                        kind: "method";
+                    };
+                    ReadAt: {
+                        kind: "method";
+                    };
+                    Seek: {
+                        kind: "method";
+                    };
+                    Size: {
+                        kind: "method";
+                    };
+                };
+            };
+            NewSectionReader: {
+                kind: "function";
+            };
+            Seeker: {
+                kind: "interface";
+                members: {
+                    Seek: {
+                        kind: "field";
+                    };
+                };
+            };
+            StringWriter: {
+                kind: "interface";
+                members: {
+                    WriteString: {
+                        kind: "field";
+                    };
+                };
+            };
+            WriteCloser: {
+                kind: "interface";
+                members: {
+                    Writer: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                    Closer: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                };
+            };
+            WriteSeeker: {
+                kind: "interface";
+                members: {
+                    Writer: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                    Seeker: {
+                        kind: "embed";
+                        type: () => any;
+                    };
+                };
+            };
+            Writer: {
+                kind: "interface";
+                members: {
+                    Write: {
+                        kind: "field";
+                    };
+                };
+            };
+            MultiWriter: {
+                kind: "function";
+            };
+            WriterAt: {
+                kind: "interface";
+                members: {
+                    WriteAt: {
+                        kind: "field";
+                    };
+                };
+            };
+            WriterTo: {
+                kind: "interface";
+                members: {
+                    WriteTo: {
+                        kind: "field";
+                    };
+                };
+            };
+        };
+    }>;
+    fmt: import("../create-module.js").LibraryFrom<{
+        kind: "package";
+        members: {
+            Append: {
+                kind: "function";
+            };
+            Appendf: {
+                kind: "function";
+            };
+            Appendln: {
+                kind: "function";
+            };
+            Errorf: {
+                kind: "function";
+            };
+            FormatString: {
+                kind: "function";
+            };
+            Fprint: {
+                kind: "function";
+            };
+            Fprintf: {
+                kind: "function";
+            };
+            Fprintln: {
+                kind: "function";
+            };
+            Fscan: {
+                kind: "function";
+            };
+            Fscanf: {
+                kind: "function";
+            };
+            Fscanln: {
+                kind: "function";
+            };
+            Print: {
+                kind: "function";
+            };
+            Printf: {
+                kind: "function";
+            };
+            Println: {
+                kind: "function";
+            };
+            Scan: {
+                kind: "function";
+            };
+            Scanf: {
+                kind: "function";
+            };
+            Scanln: {
+                kind: "function";
+            };
+            Sprint: {
+                kind: "function";
+            };
+            Sprintf: {
+                kind: "function";
+            };
+            Sprintln: {
+                kind: "function";
+            };
+            Sscan: {
+                kind: "function";
+            };
+            Sscanf: {
+                kind: "function";
+            };
+            Sscanln: {
+                kind: "function";
+            };
+            Formatter: {
+                kind: "interface";
+                members: {
+                    Format: {
+                        kind: "field";
+                    };
+                };
+            };
+            GoStringer: {
+                kind: "interface";
+                members: {
+                    GoString: {
+                        kind: "field";
+                    };
+                };
+            };
+            ScanState: {
+                kind: "interface";
+                members: {
+                    ReadRune: {
+                        kind: "field";
+                    };
+                    UnreadRune: {
+                        kind: "field";
+                    };
+                    SkipSpace: {
+                        kind: "field";
+                    };
+                    Token: {
+                        kind: "field";
+                    };
+                    Width: {
+                        kind: "field";
+                    };
+                    Read: {
+                        kind: "field";
+                    };
+                };
+            };
+            Scanner: {
+                kind: "interface";
+                members: {
+                    Scan: {
+                        kind: "field";
+                    };
+                };
+            };
+            State: {
+                kind: "interface";
+                members: {
+                    Write: {
+                        kind: "field";
+                    };
+                    Width: {
+                        kind: "field";
+                    };
+                    Precision: {
+                        kind: "field";
+                    };
+                    Flag: {
+                        kind: "field";
+                    };
+                };
+            };
+            Stringer: {
+                kind: "interface";
+                members: {
+                    String: {
+                        kind: "field";
+                    };
+                };
+            };
+        };
+    }>;
+    net: import("../create-module.js").LibraryFrom<{
+        kind: "package";
+        members: {
+            http: {
+                kind: "package";
+                members: {
+                    MethodGet: {
+                        kind: "var";
+                    };
+                    MethodHead: {
+                        kind: "var";
+                    };
+                    MethodPost: {
+                        kind: "var";
+                    };
+                    MethodPut: {
+                        kind: "var";
+                    };
+                    MethodPatch: {
+                        kind: "var";
+                    };
+                    MethodDelete: {
+                        kind: "var";
+                    };
+                    MethodConnect: {
+                        kind: "var";
+                    };
+                    MethodOptions: {
+                        kind: "var";
+                    };
+                    MethodTrace: {
+                        kind: "var";
+                    };
+                    StatusContinue: {
+                        kind: "var";
+                    };
+                    StatusSwitchingProtocols: {
+                        kind: "var";
+                    };
+                    StatusProcessing: {
+                        kind: "var";
+                    };
+                    StatusEarlyHints: {
+                        kind: "var";
+                    };
+                    StatusOK: {
+                        kind: "var";
+                    };
+                    StatusCreated: {
+                        kind: "var";
+                    };
+                    StatusAccepted: {
+                        kind: "var";
+                    };
+                    StatusNonAuthoritativeInfo: {
+                        kind: "var";
+                    };
+                    StatusNoContent: {
+                        kind: "var";
+                    };
+                    StatusResetContent: {
+                        kind: "var";
+                    };
+                    StatusPartialContent: {
+                        kind: "var";
+                    };
+                    StatusMultiStatus: {
+                        kind: "var";
+                    };
+                    StatusAlreadyReported: {
+                        kind: "var";
+                    };
+                    StatusIMUsed: {
+                        kind: "var";
+                    };
+                    StatusMultipleChoices: {
+                        kind: "var";
+                    };
+                    StatusMovedPermanently: {
+                        kind: "var";
+                    };
+                    StatusFound: {
+                        kind: "var";
+                    };
+                    StatusSeeOther: {
+                        kind: "var";
+                    };
+                    StatusNotModified: {
+                        kind: "var";
+                    };
+                    StatusUseProxy: {
+                        kind: "var";
+                    };
+                    StatusTemporaryRedirect: {
+                        kind: "var";
+                    };
+                    StatusPermanentRedirect: {
+                        kind: "var";
+                    };
+                    StatusBadRequest: {
+                        kind: "var";
+                    };
+                    StatusUnauthorized: {
+                        kind: "var";
+                    };
+                    StatusPaymentRequired: {
+                        kind: "var";
+                    };
+                    StatusForbidden: {
+                        kind: "var";
+                    };
+                    StatusNotFound: {
+                        kind: "var";
+                    };
+                    StatusMethodNotAllowed: {
+                        kind: "var";
+                    };
+                    StatusNotAcceptable: {
+                        kind: "var";
+                    };
+                    StatusProxyAuthRequired: {
+                        kind: "var";
+                    };
+                    StatusRequestTimeout: {
+                        kind: "var";
+                    };
+                    StatusConflict: {
+                        kind: "var";
+                    };
+                    StatusGone: {
+                        kind: "var";
+                    };
+                    StatusLengthRequired: {
+                        kind: "var";
+                    };
+                    StatusPreconditionFailed: {
+                        kind: "var";
+                    };
+                    StatusRequestEntityTooLarge: {
+                        kind: "var";
+                    };
+                    StatusRequestURITooLong: {
+                        kind: "var";
+                    };
+                    StatusUnsupportedMediaType: {
+                        kind: "var";
+                    };
+                    StatusRequestedRangeNotSatisfiable: {
+                        kind: "var";
+                    };
+                    StatusExpectationFailed: {
+                        kind: "var";
+                    };
+                    StatusTeapot: {
+                        kind: "var";
+                    };
+                    StatusMisdirectedRequest: {
+                        kind: "var";
+                    };
+                    StatusUnprocessableEntity: {
+                        kind: "var";
+                    };
+                    StatusLocked: {
+                        kind: "var";
+                    };
+                    StatusFailedDependency: {
+                        kind: "var";
+                    };
+                    StatusTooEarly: {
+                        kind: "var";
+                    };
+                    StatusUpgradeRequired: {
+                        kind: "var";
+                    };
+                    StatusPreconditionRequired: {
+                        kind: "var";
+                    };
+                    StatusTooManyRequests: {
+                        kind: "var";
+                    };
+                    StatusRequestHeaderFieldsTooLarge: {
+                        kind: "var";
+                    };
+                    StatusUnavailableForLegalReasons: {
+                        kind: "var";
+                    };
+                    StatusInternalServerError: {
+                        kind: "var";
+                    };
+                    StatusNotImplemented: {
+                        kind: "var";
+                    };
+                    StatusBadGateway: {
+                        kind: "var";
+                    };
+                    StatusServiceUnavailable: {
+                        kind: "var";
+                    };
+                    StatusGatewayTimeout: {
+                        kind: "var";
+                    };
+                    StatusHTTPVersionNotSupported: {
+                        kind: "var";
+                    };
+                    StatusVariantAlsoNegotiates: {
+                        kind: "var";
+                    };
+                    StatusInsufficientStorage: {
+                        kind: "var";
+                    };
+                    StatusLoopDetected: {
+                        kind: "var";
+                    };
+                    StatusNotExtended: {
+                        kind: "var";
+                    };
+                    StatusNetworkAuthenticationRequired: {
+                        kind: "var";
+                    };
+                    DefaultMaxHeaderBytes: {
+                        kind: "var";
+                    };
+                    DefaultMaxIdleConnsPerHost: {
+                        kind: "var";
+                    };
+                    TimeFormat: {
+                        kind: "var";
+                    };
+                    TrailerPrefix: {
+                        kind: "var";
+                    };
+                    ErrNotSupported: {
+                        kind: "var";
+                    };
+                    ErrMissingBoundary: {
+                        kind: "var";
+                    };
+                    ErrNotMultipart: {
+                        kind: "var";
+                    };
+                    ErrBodyNotAllowed: {
+                        kind: "var";
+                    };
+                    ErrHijacked: {
+                        kind: "var";
+                    };
+                    ErrContentLength: {
+                        kind: "var";
+                    };
+                    ServerContextKey: {
+                        kind: "var";
+                    };
+                    LocalAddrContextKey: {
+                        kind: "var";
+                    };
+                    DefaultClient: {
+                        kind: "var";
+                    };
+                    DefaultServeMux: {
+                        kind: "var";
+                    };
+                    ErrAbortHandler: {
+                        kind: "var";
+                    };
+                    ErrBodyReadAfterClose: {
+                        kind: "var";
+                    };
+                    ErrHandlerTimeout: {
+                        kind: "var";
+                    };
+                    ErrLineTooLong: {
+                        kind: "var";
+                    };
+                    ErrMissingFile: {
+                        kind: "var";
+                    };
+                    ErrNoCookie: {
+                        kind: "var";
+                    };
+                    ErrNoLocation: {
+                        kind: "var";
+                    };
+                    ErrSchemeMismatch: {
+                        kind: "var";
+                    };
+                    ErrServerClosed: {
+                        kind: "var";
+                    };
+                    ErrSkipAltProtocol: {
+                        kind: "var";
+                    };
+                    ErrUseLastResponse: {
+                        kind: "var";
+                    };
+                    NoBody: {
+                        kind: "var";
+                    };
+                    CanonicalHeaderKey: {
+                        kind: "function";
+                    };
+                    DetectContentType: {
+                        kind: "function";
+                    };
+                    Error: {
+                        kind: "function";
+                    };
+                    Handle: {
+                        kind: "function";
+                    };
+                    HandleFunc: {
+                        kind: "function";
+                    };
+                    ListenAndServe: {
+                        kind: "function";
+                    };
+                    ListenAndServeTLS: {
+                        kind: "function";
+                    };
+                    MaxBytesReader: {
+                        kind: "function";
+                    };
+                    NotFound: {
+                        kind: "function";
+                    };
+                    ParseHTTPVersion: {
+                        kind: "function";
+                    };
+                    ParseTime: {
+                        kind: "function";
+                    };
+                    ProxyFromEnvironment: {
+                        kind: "function";
+                    };
+                    ProxyURL: {
+                        kind: "function";
+                    };
+                    Redirect: {
+                        kind: "function";
+                    };
+                    Serve: {
+                        kind: "function";
+                    };
+                    ServeContent: {
+                        kind: "function";
+                    };
+                    ServeFile: {
+                        kind: "function";
+                    };
+                    ServeFileFS: {
+                        kind: "function";
+                    };
+                    ServeTLS: {
+                        kind: "function";
+                    };
+                    SetCookie: {
+                        kind: "function";
+                    };
+                    StatusText: {
+                        kind: "function";
+                    };
+                    Client: {
+                        kind: "struct";
+                        members: {
+                            Transport: {
+                                kind: "field";
+                            };
+                            CheckRedirect: {
+                                kind: "field";
+                            };
+                            Jar: {
+                                kind: "field";
+                            };
+                            Timeout: {
+                                kind: "field";
+                            };
+                            CloseIdleConnections: {
+                                kind: "method";
+                            };
+                            Do: {
+                                kind: "method";
+                            };
+                            Get: {
+                                kind: "method";
+                            };
+                            Head: {
+                                kind: "method";
+                            };
+                            Post: {
+                                kind: "method";
+                            };
+                            PostForm: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    ConnState: {
+                        kind: "type";
+                        members: {
+                            String: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    StateNew: {
+                        kind: "var";
+                    };
+                    StateActive: {
+                        kind: "var";
+                    };
+                    StateIdle: {
+                        kind: "var";
+                    };
+                    StateHijacked: {
+                        kind: "var";
+                    };
+                    StateClosed: {
+                        kind: "var";
+                    };
+                    Cookie: {
+                        kind: "struct";
+                        members: {
+                            Name: {
+                                kind: "field";
+                            };
+                            Value: {
+                                kind: "field";
+                            };
+                            Quoted: {
+                                kind: "field";
+                            };
+                            Path: {
+                                kind: "field";
+                            };
+                            Domain: {
+                                kind: "field";
+                            };
+                            Expires: {
+                                kind: "field";
+                            };
+                            RawExpires: {
+                                kind: "field";
+                            };
+                            MaxAge: {
+                                kind: "field";
+                            };
+                            Secure: {
+                                kind: "field";
+                            };
+                            HttpOnly: {
+                                kind: "field";
+                            };
+                            SameSite: {
+                                kind: "field";
+                            };
+                            Partitioned: {
+                                kind: "field";
+                            };
+                            Raw: {
+                                kind: "field";
+                            };
+                            Unparsed: {
+                                kind: "field";
+                            };
+                            String: {
+                                kind: "method";
+                            };
+                            Valid: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    ParseCookie: {
+                        kind: "function";
+                    };
+                    ParseSetCookie: {
+                        kind: "function";
+                    };
+                    CookieJar: {
+                        kind: "interface";
+                        members: {
+                            SetCookies: {
+                                kind: "field";
+                            };
+                            Cookies: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    CrossOriginProtection: {
+                        kind: "struct";
+                        members: {
+                            AddInsecureBypassPattern: {
+                                kind: "method";
+                            };
+                            AddTrustedOrigin: {
+                                kind: "method";
+                            };
+                            Check: {
+                                kind: "method";
+                            };
+                            Handler: {
+                                kind: "method";
+                            };
+                            SetDenyHandler: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    NewCrossOriginProtection: {
+                        kind: "function";
+                    };
+                    Dir: {
+                        kind: "type";
+                        members: {
+                            Open: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    File: {
+                        kind: "interface";
+                        members: {
+                            Closer: {
+                                kind: "embed";
+                                type: () => any;
+                            };
+                            Reader: {
+                                kind: "embed";
+                                type: () => any;
+                            };
+                            Seeker: {
+                                kind: "embed";
+                                type: () => any;
+                            };
+                            Readdir: {
+                                kind: "field";
+                            };
+                            Stat: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    FileSystem: {
+                        kind: "interface";
+                        members: {
+                            Open: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    FS: {
+                        kind: "function";
+                    };
+                    Flusher: {
+                        kind: "interface";
+                        members: {
+                            Flush: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    HTTP2Config: {
+                        kind: "struct";
+                        members: {
+                            MaxConcurrentStreams: {
+                                kind: "field";
+                            };
+                            MaxDecoderHeaderTableSize: {
+                                kind: "field";
+                            };
+                            MaxEncoderHeaderTableSize: {
+                                kind: "field";
+                            };
+                            MaxReadFrameSize: {
+                                kind: "field";
+                            };
+                            MaxReceiveBufferPerConnection: {
+                                kind: "field";
+                            };
+                            MaxReceiveBufferPerStream: {
+                                kind: "field";
+                            };
+                            SendPingTimeout: {
+                                kind: "field";
+                            };
+                            PingTimeout: {
+                                kind: "field";
+                            };
+                            WriteByteTimeout: {
+                                kind: "field";
+                            };
+                            CountError: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    Handler: {
+                        kind: "interface";
+                        members: {
+                            ServeHTTP: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    AllowQuerySemicolons: {
+                        kind: "function";
+                    };
+                    FileServer: {
+                        kind: "function";
+                    };
+                    FileServerFS: {
+                        kind: "function";
+                    };
+                    MaxBytesHandler: {
+                        kind: "function";
+                    };
+                    NotFoundHandler: {
+                        kind: "function";
+                    };
+                    RedirectHandler: {
+                        kind: "function";
+                    };
+                    StripPrefix: {
+                        kind: "function";
+                    };
+                    TimeoutHandler: {
+                        kind: "function";
+                    };
+                    HandlerFunc: {
+                        kind: "type";
+                        members: {
+                            ServeHTTP: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    Header: {
+                        kind: "type";
+                        members: {
+                            Add: {
+                                kind: "method";
+                            };
+                            Clone: {
+                                kind: "method";
+                            };
+                            Del: {
+                                kind: "method";
+                            };
+                            Get: {
+                                kind: "method";
+                            };
+                            Set: {
+                                kind: "method";
+                            };
+                            Values: {
+                                kind: "method";
+                            };
+                            Write: {
+                                kind: "method";
+                            };
+                            WriteSubset: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    Hijacker: {
+                        kind: "interface";
+                        members: {
+                            Hijack: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    MaxBytesError: {
+                        kind: "struct";
+                        members: {
+                            Error: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    Protocols: {
+                        kind: "struct";
+                        members: {
+                            HTTP1: {
+                                kind: "method";
+                            };
+                            HTTP2: {
+                                kind: "method";
+                            };
+                            SetHTTP1: {
+                                kind: "method";
+                            };
+                            SetHTTP2: {
+                                kind: "method";
+                            };
+                            SetUnencryptedHTTP2: {
+                                kind: "method";
+                            };
+                            String: {
+                                kind: "method";
+                            };
+                            UnencryptedHTTP2: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    PushOptions: {
+                        kind: "struct";
+                        members: {
+                            Method: {
+                                kind: "field";
+                            };
+                            Header: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    Pusher: {
+                        kind: "interface";
+                        members: {
+                            Push: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    Request: {
+                        kind: "struct";
+                        members: {
+                            Method: {
+                                kind: "field";
+                            };
+                            URL: {
+                                kind: "field";
+                            };
+                            Proto: {
+                                kind: "field";
+                            };
+                            ProtoMajor: {
+                                kind: "field";
+                            };
+                            ProtoMinor: {
+                                kind: "field";
+                            };
+                            Header: {
+                                kind: "field";
+                            };
+                            Body: {
+                                kind: "field";
+                            };
+                            GetBody: {
+                                kind: "field";
+                            };
+                            ContentLength: {
+                                kind: "field";
+                            };
+                            TransferEncoding: {
+                                kind: "field";
+                            };
+                            Close: {
+                                kind: "field";
+                            };
+                            Host: {
+                                kind: "field";
+                            };
+                            Form: {
+                                kind: "field";
+                            };
+                            PostForm: {
+                                kind: "field";
+                            };
+                            MultipartForm: {
+                                kind: "field";
+                            };
+                            Trailer: {
+                                kind: "field";
+                            };
+                            RemoteAddr: {
+                                kind: "field";
+                            };
+                            RequestURI: {
+                                kind: "field";
+                            };
+                            TLS: {
+                                kind: "field";
+                            };
+                            Cancel: {
+                                kind: "field";
+                            };
+                            Response: {
+                                kind: "field";
+                            };
+                            Pattern: {
+                                kind: "field";
+                            };
+                            AddCookie: {
+                                kind: "method";
+                            };
+                            BasicAuth: {
+                                kind: "method";
+                            };
+                            Clone: {
+                                kind: "method";
+                            };
+                            Context: {
+                                kind: "method";
+                            };
+                            Cookie: {
+                                kind: "method";
+                            };
+                            Cookies: {
+                                kind: "method";
+                            };
+                            CookiesNamed: {
+                                kind: "method";
+                            };
+                            FormFile: {
+                                kind: "method";
+                            };
+                            FormValue: {
+                                kind: "method";
+                            };
+                            MultipartReader: {
+                                kind: "method";
+                            };
+                            ParseForm: {
+                                kind: "method";
+                            };
+                            ParseMultipartForm: {
+                                kind: "method";
+                            };
+                            PathValue: {
+                                kind: "method";
+                            };
+                            PostFormValue: {
+                                kind: "method";
+                            };
+                            ProtoAtLeast: {
+                                kind: "method";
+                            };
+                            Referer: {
+                                kind: "method";
+                            };
+                            SetBasicAuth: {
+                                kind: "method";
+                            };
+                            SetPathValue: {
+                                kind: "method";
+                            };
+                            UserAgent: {
+                                kind: "method";
+                            };
+                            WithContext: {
+                                kind: "method";
+                            };
+                            Write: {
+                                kind: "method";
+                            };
+                            WriteProxy: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    NewRequest: {
+                        kind: "function";
+                    };
+                    NewRequestWithContext: {
+                        kind: "function";
+                    };
+                    ReadRequest: {
+                        kind: "function";
+                    };
+                    Response: {
+                        kind: "struct";
+                        members: {
+                            Status: {
+                                kind: "field";
+                            };
+                            StatusCode: {
+                                kind: "field";
+                            };
+                            Proto: {
+                                kind: "field";
+                            };
+                            ProtoMajor: {
+                                kind: "field";
+                            };
+                            ProtoMinor: {
+                                kind: "field";
+                            };
+                            Header: {
+                                kind: "field";
+                            };
+                            Body: {
+                                kind: "field";
+                            };
+                            ContentLength: {
+                                kind: "field";
+                            };
+                            TransferEncoding: {
+                                kind: "field";
+                            };
+                            Close: {
+                                kind: "field";
+                            };
+                            Uncompressed: {
+                                kind: "field";
+                            };
+                            Trailer: {
+                                kind: "field";
+                            };
+                            Request: {
+                                kind: "field";
+                            };
+                            TLS: {
+                                kind: "field";
+                            };
+                            Cookies: {
+                                kind: "method";
+                            };
+                            Location: {
+                                kind: "method";
+                            };
+                            ProtoAtLeast: {
+                                kind: "method";
+                            };
+                            Write: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    Get: {
+                        kind: "function";
+                    };
+                    Head: {
+                        kind: "function";
+                    };
+                    Post: {
+                        kind: "function";
+                    };
+                    PostForm: {
+                        kind: "function";
+                    };
+                    ReadResponse: {
+                        kind: "function";
+                    };
+                    ResponseController: {
+                        kind: "struct";
+                        members: {
+                            EnableFullDuplex: {
+                                kind: "method";
+                            };
+                            Flush: {
+                                kind: "method";
+                            };
+                            Hijack: {
+                                kind: "method";
+                            };
+                            SetReadDeadline: {
+                                kind: "method";
+                            };
+                            SetWriteDeadline: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    NewResponseController: {
+                        kind: "function";
+                    };
+                    ResponseWriter: {
+                        kind: "interface";
+                        members: {
+                            Header: {
+                                kind: "field";
+                            };
+                            Write: {
+                                kind: "field";
+                            };
+                            WriteHeader: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    RoundTripper: {
+                        kind: "interface";
+                        members: {
+                            RoundTrip: {
+                                kind: "field";
+                            };
+                        };
+                    };
+                    DefaultTransport: {
+                        kind: "var";
+                    };
+                    NewFileTransport: {
+                        kind: "function";
+                    };
+                    SameSite: {
+                        kind: "type";
+                        members: {};
+                    };
+                    SameSiteDefaultMode: {
+                        kind: "var";
+                    };
+                    SameSiteLaxMode: {
+                        kind: "var";
+                    };
+                    SameSiteStrictMode: {
+                        kind: "var";
+                    };
+                    SameSiteNoneMode: {
+                        kind: "var";
+                    };
+                    ServeMux: {
+                        kind: "struct";
+                        members: {
+                            Handle: {
+                                kind: "method";
+                            };
+                            HandleFunc: {
+                                kind: "method";
+                            };
+                            Handler: {
+                                kind: "method";
+                            };
+                            ServeHTTP: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    NewServeMux: {
+                        kind: "function";
+                    };
+                    Server: {
+                        kind: "struct";
+                        members: {
+                            Addr: {
+                                kind: "field";
+                            };
+                            Handler: {
+                                kind: "field";
+                            };
+                            DisableGeneralOptionsHandler: {
+                                kind: "field";
+                            };
+                            TLSConfig: {
+                                kind: "field";
+                            };
+                            ReadTimeout: {
+                                kind: "field";
+                            };
+                            ReadHeaderTimeout: {
+                                kind: "field";
+                            };
+                            WriteTimeout: {
+                                kind: "field";
+                            };
+                            IdleTimeout: {
+                                kind: "field";
+                            };
+                            MaxHeaderBytes: {
+                                kind: "field";
+                            };
+                            TLSNextProto: {
+                                kind: "field";
+                            };
+                            ConnState: {
+                                kind: "field";
+                            };
+                            ErrorLog: {
+                                kind: "field";
+                            };
+                            BaseContext: {
+                                kind: "field";
+                            };
+                            ConnContext: {
+                                kind: "field";
+                            };
+                            HTTP2: {
+                                kind: "field";
+                            };
+                            Protocols: {
+                                kind: "field";
+                            };
+                            Close: {
+                                kind: "method";
+                            };
+                            ListenAndServe: {
+                                kind: "method";
+                            };
+                            ListenAndServeTLS: {
+                                kind: "method";
+                            };
+                            RegisterOnShutdown: {
+                                kind: "method";
+                            };
+                            Serve: {
+                                kind: "method";
+                            };
+                            ServeTLS: {
+                                kind: "method";
+                            };
+                            SetKeepAlivesEnabled: {
+                                kind: "method";
+                            };
+                            Shutdown: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                    Transport: {
+                        kind: "struct";
+                        members: {
+                            Proxy: {
+                                kind: "field";
+                            };
+                            OnProxyConnectResponse: {
+                                kind: "field";
+                            };
+                            DialContext: {
+                                kind: "field";
+                            };
+                            Dial: {
+                                kind: "field";
+                            };
+                            DialTLSContext: {
+                                kind: "field";
+                            };
+                            DialTLS: {
+                                kind: "field";
+                            };
+                            TLSClientConfig: {
+                                kind: "field";
+                            };
+                            TLSHandshakeTimeout: {
+                                kind: "field";
+                            };
+                            DisableKeepAlives: {
+                                kind: "field";
+                            };
+                            DisableCompression: {
+                                kind: "field";
+                            };
+                            MaxIdleConns: {
+                                kind: "field";
+                            };
+                            MaxIdleConnsPerHost: {
+                                kind: "field";
+                            };
+                            MaxConnsPerHost: {
+                                kind: "field";
+                            };
+                            IdleConnTimeout: {
+                                kind: "field";
+                            };
+                            ResponseHeaderTimeout: {
+                                kind: "field";
+                            };
+                            ExpectContinueTimeout: {
+                                kind: "field";
+                            };
+                            TLSNextProto: {
+                                kind: "field";
+                            };
+                            ProxyConnectHeader: {
+                                kind: "field";
+                            };
+                            GetProxyConnectHeader: {
+                                kind: "field";
+                            };
+                            MaxResponseHeaderBytes: {
+                                kind: "field";
+                            };
+                            WriteBufferSize: {
+                                kind: "field";
+                            };
+                            ReadBufferSize: {
+                                kind: "field";
+                            };
+                            ForceAttemptHTTP2: {
+                                kind: "field";
+                            };
+                            HTTP2: {
+                                kind: "field";
+                            };
+                            Protocols: {
+                                kind: "field";
+                            };
+                            CancelRequest: {
+                                kind: "method";
+                            };
+                            Clone: {
+                                kind: "method";
+                            };
+                            CloseIdleConnections: {
+                                kind: "method";
+                            };
+                            RegisterProtocol: {
+                                kind: "method";
+                            };
+                            RoundTrip: {
+                                kind: "method";
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    }>;
+    time: import("../create-module.js").LibraryFrom<{
+        kind: "package";
+        members: {
+            After: {
+                kind: "function";
+            };
+            AfterFunc: {
+                kind: "function";
+            };
+            Date: {
+                kind: "function";
+            };
+            FixedZone: {
+                kind: "function";
+            };
+            LoadLocation: {
+                kind: "function";
+            };
+            LoadLocationFromTZData: {
+                kind: "function";
+            };
+            NewTicker: {
+                kind: "function";
+            };
+            NewTimer: {
+                kind: "function";
+            };
+            Now: {
+                kind: "function";
+            };
+            Parse: {
+                kind: "function";
+            };
+            ParseDuration: {
+                kind: "function";
+            };
+            ParseInLocation: {
+                kind: "function";
+            };
+            Since: {
+                kind: "function";
+            };
+            Sleep: {
+                kind: "function";
+            };
+            Tick: {
+                kind: "function";
+            };
+            Unix: {
+                kind: "function";
+            };
+            UnixMicro: {
+                kind: "function";
+            };
+            UnixMilli: {
+                kind: "function";
+            };
+            Until: {
+                kind: "function";
+            };
+            Layout: {
+                kind: "var";
+            };
+            ANSIC: {
+                kind: "var";
+            };
+            UnixDate: {
+                kind: "var";
+            };
+            RubyDate: {
+                kind: "var";
+            };
+            RFC822: {
+                kind: "var";
+            };
+            RFC822Z: {
+                kind: "var";
+            };
+            RFC850: {
+                kind: "var";
+            };
+            RFC1123: {
+                kind: "var";
+            };
+            RFC1123Z: {
+                kind: "var";
+            };
+            RFC3339: {
+                kind: "var";
+            };
+            RFC3339Nano: {
+                kind: "var";
+            };
+            Kitchen: {
+                kind: "var";
+            };
+            Stamp: {
+                kind: "var";
+            };
+            StampMilli: {
+                kind: "var";
+            };
+            StampMicro: {
+                kind: "var";
+            };
+            StampNano: {
+                kind: "var";
+            };
+            DateTime: {
+                kind: "var";
+            };
+            DateOnly: {
+                kind: "var";
+            };
+            TimeOnly: {
+                kind: "var";
+            };
+            Nanosecond: {
+                kind: "var";
+            };
+            Microsecond: {
+                kind: "var";
+            };
+            Millisecond: {
+                kind: "var";
+            };
+            Second: {
+                kind: "var";
+            };
+            Minute: {
+                kind: "var";
+            };
+            Hour: {
+                kind: "var";
+            };
+            January: {
+                kind: "var";
+            };
+            February: {
+                kind: "var";
+            };
+            March: {
+                kind: "var";
+            };
+            April: {
+                kind: "var";
+            };
+            May: {
+                kind: "var";
+            };
+            June: {
+                kind: "var";
+            };
+            July: {
+                kind: "var";
+            };
+            August: {
+                kind: "var";
+            };
+            September: {
+                kind: "var";
+            };
+            October: {
+                kind: "var";
+            };
+            November: {
+                kind: "var";
+            };
+            December: {
+                kind: "var";
+            };
+            Sunday: {
+                kind: "var";
+            };
+            Monday: {
+                kind: "var";
+            };
+            Tuesday: {
+                kind: "var";
+            };
+            Wednesday: {
+                kind: "var";
+            };
+            Thursday: {
+                kind: "var";
+            };
+            Friday: {
+                kind: "var";
+            };
+            Saturday: {
+                kind: "var";
+            };
+            UTC: {
+                kind: "var";
+            };
+            Local: {
+                kind: "var";
+            };
+            Duration: {
+                kind: "type";
+                members: {
+                    Abs: {
+                        kind: "field";
+                    };
+                    Hours: {
+                        kind: "field";
+                    };
+                    Microseconds: {
+                        kind: "field";
+                    };
+                    Milliseconds: {
+                        kind: "field";
+                    };
+                    Minutes: {
+                        kind: "field";
+                    };
+                    Nanoseconds: {
+                        kind: "field";
+                    };
+                    Round: {
+                        kind: "field";
+                    };
+                    Seconds: {
+                        kind: "field";
+                    };
+                    String: {
+                        kind: "field";
+                    };
+                    Truncate: {
+                        kind: "field";
+                    };
+                };
+            };
+            Location: {
+                kind: "type";
+                members: {
+                    String: {
+                        kind: "field";
+                    };
+                };
+            };
+            Month: {
+                kind: "type";
+                members: {
+                    String: {
+                        kind: "field";
+                    };
+                };
+            };
+            ParseError: {
+                kind: "type";
+                members: {
+                    Layout: {
+                        kind: "field";
+                    };
+                    Value: {
+                        kind: "field";
+                    };
+                    LayoutElem: {
+                        kind: "field";
+                    };
+                    ValueElem: {
+                        kind: "field";
+                    };
+                    Message: {
+                        kind: "field";
+                    };
+                    Error: {
+                        kind: "field";
+                    };
+                };
+            };
+            Ticker: {
+                kind: "type";
+                members: {
+                    C: {
+                        kind: "field";
+                    };
+                    Reset: {
+                        kind: "field";
+                    };
+                    Stop: {
+                        kind: "field";
+                    };
+                };
+            };
+            Time: {
+                kind: "type";
+                members: {
+                    Add: {
+                        kind: "field";
+                    };
+                    AddDate: {
+                        kind: "field";
+                    };
+                    After: {
+                        kind: "field";
+                    };
+                    AppendBinary: {
+                        kind: "field";
+                    };
+                    AppendFormat: {
+                        kind: "field";
+                    };
+                    AppendText: {
+                        kind: "field";
+                    };
+                    Before: {
+                        kind: "field";
+                    };
+                    Clock: {
+                        kind: "field";
+                    };
+                    Compare: {
+                        kind: "field";
+                    };
+                    Date: {
+                        kind: "field";
+                    };
+                    Day: {
+                        kind: "field";
+                    };
+                    Equal: {
+                        kind: "field";
+                    };
+                    Format: {
+                        kind: "field";
+                    };
+                    GoString: {
+                        kind: "field";
+                    };
+                    GobDecode: {
+                        kind: "field";
+                    };
+                    GobEncode: {
+                        kind: "field";
+                    };
+                    Hour: {
+                        kind: "field";
+                    };
+                    ISOWeek: {
+                        kind: "field";
+                    };
+                    In: {
+                        kind: "field";
+                    };
+                    IsDST: {
+                        kind: "field";
+                    };
+                    IsZero: {
+                        kind: "field";
+                    };
+                    Local: {
+                        kind: "field";
+                    };
+                    Location: {
+                        kind: "field";
+                    };
+                    MarshalBinary: {
+                        kind: "field";
+                    };
+                    MarshalJSON: {
+                        kind: "field";
+                    };
+                    MarshalText: {
+                        kind: "field";
+                    };
+                    Minute: {
+                        kind: "field";
+                    };
+                    Month: {
+                        kind: "field";
+                    };
+                    Nanosecond: {
+                        kind: "field";
+                    };
+                    Round: {
+                        kind: "field";
+                    };
+                    Second: {
+                        kind: "field";
+                    };
+                    String: {
+                        kind: "field";
+                    };
+                    Sub: {
+                        kind: "field";
+                    };
+                    Truncate: {
+                        kind: "field";
+                    };
+                    UTC: {
+                        kind: "field";
+                    };
+                    Unix: {
+                        kind: "field";
+                    };
+                    UnixMicro: {
+                        kind: "field";
+                    };
+                    UnixMilli: {
+                        kind: "field";
+                    };
+                    UnixNano: {
+                        kind: "field";
+                    };
+                    UnmarshalBinary: {
+                        kind: "field";
+                    };
+                    UnmarshalJSON: {
+                        kind: "field";
+                    };
+                    UnmarshalText: {
+                        kind: "field";
+                    };
+                    Weekday: {
+                        kind: "field";
+                    };
+                    Year: {
+                        kind: "field";
+                    };
+                    YearDay: {
+                        kind: "field";
+                    };
+                    Zone: {
+                        kind: "field";
+                    };
+                    ZoneBounds: {
+                        kind: "field";
+                    };
+                };
+            };
+            Timer: {
+                kind: "type";
+                members: {
+                    C: {
+                        kind: "field";
+                    };
+                    Reset: {
+                        kind: "field";
+                    };
+                    Stop: {
+                        kind: "field";
+                    };
+                };
+            };
+            Weekday: {
+                kind: "type";
+                members: {
+                    String: {
+                        kind: "field";
+                    };
+                };
+            };
+        };
+    }>;
+}
+```